yt_dlp/extractor/youtube.py

   1 import base64
   2 import calendar
   3 import collections
   4 import copy
   5 import datetime as dt
   6 import enum
   7 import hashlib
   8 import itertools
   9 import json
  10 import math
  11 import os.path
  12 import random
  13 import re
  14 import shlex
  15 import sys
  16 import threading
  17 import time
  18 import traceback
  19 import urllib.parse
  20
  21 from .common import InfoExtractor, SearchInfoExtractor
  22 from .openload import PhantomJSwrapper
  23 from ..compat import functools
  24 from ..jsinterp import JSInterpreter
  25 from ..networking.exceptions import HTTPError, network_exceptions
  26 from ..utils import (
  27     NO_DEFAULT,
  28     ExtractorError,
  29     LazyList,
  30     UserNotLive,
  31     bug_reports_message,
  32     classproperty,
  33     clean_html,
  34     datetime_from_str,
  35     dict_get,
  36     filesize_from_tbr,
  37     filter_dict,
  38     float_or_none,
  39     format_field,
  40     get_first,
  41     int_or_none,
  42     is_html,
  43     join_nonempty,
  44     js_to_json,
  45     mimetype2ext,
  46     orderedSet,
  47     parse_codecs,
  48     parse_count,
  49     parse_duration,
  50     parse_iso8601,
  51     parse_qs,
  52     qualities,
  53     remove_start,
  54     smuggle_url,
  55     str_or_none,
  56     str_to_int,
  57     strftime_or_none,
  58     traverse_obj,
  59     try_call,
  60     try_get,
  61     unescapeHTML,
  62     unified_strdate,
  63     unified_timestamp,
  64     unsmuggle_url,
  65     update_url_query,
  66     url_or_none,
  67     urljoin,
  68     variadic,
  69 )
  70
  71 STREAMING_DATA_CLIENT_NAME = '__yt_dlp_client'
  72 # any clients starting with _ cannot be explicitly requested by the user
  73 INNERTUBE_CLIENTS = {
  74     'web': {
  75         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
  76         'INNERTUBE_CONTEXT': {
  77             'client': {
  78                 'clientName': 'WEB',
  79                 'clientVersion': '2.20220801.00.00',
  80             },
  81         },
  82         'INNERTUBE_CONTEXT_CLIENT_NAME': 1,
  83     },
  84     'web_embedded': {
  85         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
  86         'INNERTUBE_CONTEXT': {
  87             'client': {
  88                 'clientName': 'WEB_EMBEDDED_PLAYER',
  89                 'clientVersion': '1.20220731.00.00',
  90             },
  91         },
  92         'INNERTUBE_CONTEXT_CLIENT_NAME': 56,
  93     },
  94     'web_music': {
  95         'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
  96         'INNERTUBE_HOST': 'music.youtube.com',
  97         'INNERTUBE_CONTEXT': {
  98             'client': {
  99                 'clientName': 'WEB_REMIX',
 100                 'clientVersion': '1.20220727.01.00',
 101             },
 102         },
 103         'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
 104     },
 105     'web_creator': {
 106         'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
 107         'INNERTUBE_CONTEXT': {
 108             'client': {
 109                 'clientName': 'WEB_CREATOR',
 110                 'clientVersion': '1.20220726.00.00',
 111             },
 112         },
 113         'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
 114     },
 115     'android': {
 116         'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
 117         'INNERTUBE_CONTEXT': {
 118             'client': {
 119                 'clientName': 'ANDROID',
 120                 'clientVersion': '19.09.37',
 121                 'androidSdkVersion': 30,
 122                 'userAgent': 'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
 123             },
 124         },
 125         'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
 126         'REQUIRE_JS_PLAYER': False,
 127     },
 128     'android_embedded': {
 129         'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
 130         'INNERTUBE_CONTEXT': {
 131             'client': {
 132                 'clientName': 'ANDROID_EMBEDDED_PLAYER',
 133                 'clientVersion': '19.09.37',
 134                 'androidSdkVersion': 30,
 135                 'userAgent': 'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
 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': '6.42.52',
 147                 'androidSdkVersion': 30,
 148                 'userAgent': 'com.google.android.apps.youtube.music/6.42.52 (Linux; U; Android 11) gzip',
 149             },
 150         },
 151         'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
 152         'REQUIRE_JS_PLAYER': False,
 153     },
 154     'android_creator': {
 155         'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
 156         'INNERTUBE_CONTEXT': {
 157             'client': {
 158                 'clientName': 'ANDROID_CREATOR',
 159                 'clientVersion': '22.30.100',
 160                 'androidSdkVersion': 30,
 161                 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip',
 162             },
 163         },
 164         'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
 165         'REQUIRE_JS_PLAYER': False,
 166     },
 167     # iOS clients have HLS live streams. Setting device model to get 60fps formats.
 168     # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
 169     'ios': {
 170         'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
 171         'INNERTUBE_CONTEXT': {
 172             'client': {
 173                 'clientName': 'IOS',
 174                 'clientVersion': '19.09.3',
 175                 'deviceModel': 'iPhone14,3',
 176                 'userAgent': 'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
 177             },
 178         },
 179         'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
 180         'REQUIRE_JS_PLAYER': False,
 181     },
 182     'ios_embedded': {
 183         'INNERTUBE_CONTEXT': {
 184             'client': {
 185                 'clientName': 'IOS_MESSAGES_EXTENSION',
 186                 'clientVersion': '19.09.3',
 187                 'deviceModel': 'iPhone14,3',
 188                 'userAgent': 'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
 189             },
 190         },
 191         'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
 192         'REQUIRE_JS_PLAYER': False,
 193     },
 194     'ios_music': {
 195         'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
 196         'INNERTUBE_CONTEXT': {
 197             'client': {
 198                 'clientName': 'IOS_MUSIC',
 199                 'clientVersion': '6.33.3',
 200                 'deviceModel': 'iPhone14,3',
 201                 'userAgent': 'com.google.ios.youtubemusic/6.33.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
 202             },
 203         },
 204         'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
 205         'REQUIRE_JS_PLAYER': False,
 206     },
 207     'ios_creator': {
 208         'INNERTUBE_CONTEXT': {
 209             'client': {
 210                 'clientName': 'IOS_CREATOR',
 211                 'clientVersion': '22.33.101',
 212                 'deviceModel': 'iPhone14,3',
 213                 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
 214             },
 215         },
 216         'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
 217         'REQUIRE_JS_PLAYER': False,
 218     },
 219     # mweb has 'ultralow' formats
 220     # See: https://github.com/yt-dlp/yt-dlp/pull/557
 221     'mweb': {
 222         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
 223         'INNERTUBE_CONTEXT': {
 224             'client': {
 225                 'clientName': 'MWEB',
 226                 'clientVersion': '2.20220801.00.00',
 227             },
 228         },
 229         'INNERTUBE_CONTEXT_CLIENT_NAME': 2,
 230     },
 231     # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
 232     # See: https://github.com/zerodytrash/YouTube-Internal-Clients
 233     'tv_embedded': {
 234         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
 235         'INNERTUBE_CONTEXT': {
 236             'client': {
 237                 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
 238                 'clientVersion': '2.0',
 239             },
 240         },
 241         'INNERTUBE_CONTEXT_CLIENT_NAME': 85,
 242     },
 243     # This client has pre-merged video+audio 720p/1080p streams
 244     'mediaconnect': {
 245         'INNERTUBE_CONTEXT': {
 246             'client': {
 247                 'clientName': 'MEDIA_CONNECT_FRONTEND',
 248                 'clientVersion': '0.1',
 249             },
 250         },
 251         'INNERTUBE_CONTEXT_CLIENT_NAME': 95,
 252     },
 253 }
 254
 255
 256 def _split_innertube_client(client_name):
 257     variant, *base = client_name.rsplit('.', 1)
 258     if base:
 259         return variant, base[0], variant
 260     base, *variant = client_name.split('_', 1)
 261     return client_name, base, variant[0] if variant else None
 262
 263
 264 def short_client_name(client_name):
 265     main, *parts = _split_innertube_client(client_name)[0].replace('embedscreen', 'e_s').split('_')
 266     return join_nonempty(main[:4], ''.join(x[0] for x in parts)).upper()
 267
 268
 269 def build_innertube_clients():
 270     THIRD_PARTY = {
 271         'embedUrl': 'https://www.youtube.com/',  # Can be any valid URL
 272     }
 273     BASE_CLIENTS = ('ios', 'android', 'web', 'tv', 'mweb')
 274     priority = qualities(BASE_CLIENTS[::-1])
 275
 276     for client, ytcfg in tuple(INNERTUBE_CLIENTS.items()):
 277         ytcfg.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
 278         ytcfg.setdefault('INNERTUBE_HOST', 'www.youtube.com')
 279         ytcfg.setdefault('REQUIRE_JS_PLAYER', True)
 280         ytcfg['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
 281
 282         _, base_client, variant = _split_innertube_client(client)
 283         ytcfg['priority'] = 10 * priority(base_client)
 284
 285         if not variant:
 286             INNERTUBE_CLIENTS[f'{client}_embedscreen'] = embedscreen = copy.deepcopy(ytcfg)
 287             embedscreen['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
 288             embedscreen['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
 289             embedscreen['priority'] -= 3
 290         elif variant == 'embedded':
 291             ytcfg['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
 292             ytcfg['priority'] -= 2
 293         else:
 294             ytcfg['priority'] -= 3
 295
 296
 297 build_innertube_clients()
 298
 299
 300 class BadgeType(enum.Enum):
 301     AVAILABILITY_UNLISTED = enum.auto()
 302     AVAILABILITY_PRIVATE = enum.auto()
 303     AVAILABILITY_PUBLIC = enum.auto()
 304     AVAILABILITY_PREMIUM = enum.auto()
 305     AVAILABILITY_SUBSCRIPTION = enum.auto()
 306     LIVE_NOW = enum.auto()
 307     VERIFIED = enum.auto()
 308
 309
 310 class YoutubeBaseInfoExtractor(InfoExtractor):
 311     """Provide base functions for Youtube extractors"""
 312
 313     _RESERVED_NAMES = (
 314         r'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
 315         r'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
 316         r'browse|oembed|get_video_info|iframe_api|s/player|source|'
 317         r'storefront|oops|index|account|t/terms|about|upload|signin|logout')
 318
 319     _PLAYLIST_ID_RE = r'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
 320
 321     # _NETRC_MACHINE = 'youtube'
 322
 323     # If True it will raise an error if no login info is provided
 324     _LOGIN_REQUIRED = False
 325
 326     _INVIDIOUS_SITES = (
 327         # invidious-redirect websites
 328         r'(?:www\.)?redirect\.invidious\.io',
 329         r'(?:(?:www|dev)\.)?invidio\.us',
 330         # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
 331         r'(?:www\.)?invidious\.pussthecat\.org',
 332         r'(?:www\.)?invidious\.zee\.li',
 333         r'(?:www\.)?invidious\.ethibox\.fr',
 334         r'(?:www\.)?iv\.ggtyler\.dev',
 335         r'(?:www\.)?inv\.vern\.i2p',
 336         r'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
 337         r'(?:www\.)?inv\.riverside\.rocks',
 338         r'(?:www\.)?invidious\.silur\.me',
 339         r'(?:www\.)?inv\.bp\.projectsegfau\.lt',
 340         r'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
 341         r'(?:www\.)?invidious\.slipfox\.xyz',
 342         r'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
 343         r'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
 344         r'(?:www\.)?invidious\.tiekoetter\.com',
 345         r'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
 346         r'(?:www\.)?invidious\.nerdvpn\.de',
 347         r'(?:www\.)?invidious\.weblibre\.org',
 348         r'(?:www\.)?inv\.odyssey346\.dev',
 349         r'(?:www\.)?invidious\.dhusch\.de',
 350         r'(?:www\.)?iv\.melmac\.space',
 351         r'(?:www\.)?watch\.thekitty\.zone',
 352         r'(?:www\.)?invidious\.privacydev\.net',
 353         r'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
 354         r'(?:www\.)?invidious\.drivet\.xyz',
 355         r'(?:www\.)?vid\.priv\.au',
 356         r'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
 357         r'(?:www\.)?inv\.vern\.cc',
 358         r'(?:www\.)?invidious\.esmailelbob\.xyz',
 359         r'(?:www\.)?invidious\.sethforprivacy\.com',
 360         r'(?:www\.)?yt\.oelrichsgarcia\.de',
 361         r'(?:www\.)?yt\.artemislena\.eu',
 362         r'(?:www\.)?invidious\.flokinet\.to',
 363         r'(?:www\.)?invidious\.baczek\.me',
 364         r'(?:www\.)?y\.com\.sb',
 365         r'(?:www\.)?invidious\.epicsite\.xyz',
 366         r'(?:www\.)?invidious\.lidarshield\.cloud',
 367         r'(?:www\.)?yt\.funami\.tech',
 368         r'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
 369         r'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
 370         r'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
 371         # youtube-dl invidious instances list
 372         r'(?:(?:www|no)\.)?invidiou\.sh',
 373         r'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
 374         r'(?:www\.)?invidious\.kabi\.tk',
 375         r'(?:www\.)?invidious\.mastodon\.host',
 376         r'(?:www\.)?invidious\.zapashcanon\.fr',
 377         r'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
 378         r'(?:www\.)?invidious\.tinfoil-hat\.net',
 379         r'(?:www\.)?invidious\.himiko\.cloud',
 380         r'(?:www\.)?invidious\.reallyancient\.tech',
 381         r'(?:www\.)?invidious\.tube',
 382         r'(?:www\.)?invidiou\.site',
 383         r'(?:www\.)?invidious\.site',
 384         r'(?:www\.)?invidious\.xyz',
 385         r'(?:www\.)?invidious\.nixnet\.xyz',
 386         r'(?:www\.)?invidious\.048596\.xyz',
 387         r'(?:www\.)?invidious\.drycat\.fr',
 388         r'(?:www\.)?inv\.skyn3t\.in',
 389         r'(?:www\.)?tube\.poal\.co',
 390         r'(?:www\.)?tube\.connect\.cafe',
 391         r'(?:www\.)?vid\.wxzm\.sx',
 392         r'(?:www\.)?vid\.mint\.lgbt',
 393         r'(?:www\.)?vid\.puffyan\.us',
 394         r'(?:www\.)?yewtu\.be',
 395         r'(?:www\.)?yt\.elukerio\.org',
 396         r'(?:www\.)?yt\.lelux\.fi',
 397         r'(?:www\.)?invidious\.ggc-project\.de',
 398         r'(?:www\.)?yt\.maisputain\.ovh',
 399         r'(?:www\.)?ytprivate\.com',
 400         r'(?:www\.)?invidious\.13ad\.de',
 401         r'(?:www\.)?invidious\.toot\.koeln',
 402         r'(?:www\.)?invidious\.fdn\.fr',
 403         r'(?:www\.)?watch\.nettohikari\.com',
 404         r'(?:www\.)?invidious\.namazso\.eu',
 405         r'(?:www\.)?invidious\.silkky\.cloud',
 406         r'(?:www\.)?invidious\.exonip\.de',
 407         r'(?:www\.)?invidious\.riverside\.rocks',
 408         r'(?:www\.)?invidious\.blamefran\.net',
 409         r'(?:www\.)?invidious\.moomoo\.de',
 410         r'(?:www\.)?ytb\.trom\.tf',
 411         r'(?:www\.)?yt\.cyberhost\.uk',
 412         r'(?:www\.)?kgg2m7yk5aybusll\.onion',
 413         r'(?:www\.)?qklhadlycap4cnod\.onion',
 414         r'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
 415         r'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
 416         r'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
 417         r'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
 418         r'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
 419         r'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
 420         r'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
 421         r'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
 422         r'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
 423         r'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
 424         # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
 425         r'(?:www\.)?piped\.kavin\.rocks',
 426         r'(?:www\.)?piped\.tokhmi\.xyz',
 427         r'(?:www\.)?piped\.syncpundit\.io',
 428         r'(?:www\.)?piped\.mha\.fi',
 429         r'(?:www\.)?watch\.whatever\.social',
 430         r'(?:www\.)?piped\.garudalinux\.org',
 431         r'(?:www\.)?piped\.rivo\.lol',
 432         r'(?:www\.)?piped-libre\.kavin\.rocks',
 433         r'(?:www\.)?yt\.jae\.fi',
 434         r'(?:www\.)?piped\.mint\.lgbt',
 435         r'(?:www\.)?il\.ax',
 436         r'(?:www\.)?piped\.esmailelbob\.xyz',
 437         r'(?:www\.)?piped\.projectsegfau\.lt',
 438         r'(?:www\.)?piped\.privacydev\.net',
 439         r'(?:www\.)?piped\.palveluntarjoaja\.eu',
 440         r'(?:www\.)?piped\.smnz\.de',
 441         r'(?:www\.)?piped\.adminforge\.de',
 442         r'(?:www\.)?watch\.whatevertinfoil\.de',
 443         r'(?:www\.)?piped\.qdi\.fi',
 444         r'(?:(?:www|cf)\.)?piped\.video',
 445         r'(?:www\.)?piped\.aeong\.one',
 446         r'(?:www\.)?piped\.moomoo\.me',
 447         r'(?:www\.)?piped\.chauvet\.pro',
 448         r'(?:www\.)?watch\.leptons\.xyz',
 449         r'(?:www\.)?pd\.vern\.cc',
 450         r'(?:www\.)?piped\.hostux\.net',
 451         r'(?:www\.)?piped\.lunar\.icu',
 452         # Hyperpipe instances from https://hyperpipe.codeberg.page/
 453         r'(?:www\.)?hyperpipe\.surge\.sh',
 454         r'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
 455         r'(?:www\.)?listen\.whatever\.social',
 456         r'(?:www\.)?music\.adminforge\.de',
 457     )
 458
 459     # extracted from account/account_menu ep
 460     # XXX: These are the supported YouTube UI and API languages,
 461     # which is slightly different from languages supported for translation in YouTube studio
 462     _SUPPORTED_LANG_CODES = [
 463         'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
 464         'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
 465         'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
 466         'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
 467         'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
 468         'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko',
 469     ]
 470
 471     _IGNORED_WARNINGS = {'Unavailable videos will be hidden during playback'}
 472
 473     _YT_HANDLE_RE = r'@[\w.-]{3,30}'  # https://support.google.com/youtube/answer/11585688?hl=en
 474     _YT_CHANNEL_UCID_RE = r'UC[\w-]{22}'
 475
 476     def ucid_or_none(self, ucid):
 477         return self._search_regex(rf'^({self._YT_CHANNEL_UCID_RE})$', ucid, 'UC-id', default=None)
 478
 479     def handle_or_none(self, handle):
 480         return self._search_regex(rf'^({self._YT_HANDLE_RE})$', handle, '@-handle', default=None)
 481
 482     def handle_from_url(self, url):
 483         return self._search_regex(rf'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
 484                                   url, 'channel handle', default=None)
 485
 486     def ucid_from_url(self, url):
 487         return self._search_regex(rf'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
 488                                   url, 'channel id', default=None)
 489
 490     @functools.cached_property
 491     def _preferred_lang(self):
 492         """
 493         Returns a language code supported by YouTube for the user preferred language.
 494         Returns None if no preferred language set.
 495         """
 496         preferred_lang = self._configuration_arg('lang', ie_key='Youtube', casesense=True, default=[''])[0]
 497         if not preferred_lang:
 498             return
 499         if preferred_lang not in self._SUPPORTED_LANG_CODES:
 500             raise ExtractorError(
 501                 f'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
 502                 expected=True)
 503         elif preferred_lang != 'en':
 504             self.report_warning(
 505                 f'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
 506         return preferred_lang
 507
 508     def _initialize_consent(self):
 509         cookies = self._get_cookies('https://www.youtube.com/')
 510         if cookies.get('__Secure-3PSID'):
 511             return
 512         socs = cookies.get('SOCS')
 513         if socs and not socs.value.startswith('CAA'):  # not consented
 514             return
 515         self._set_cookie('.youtube.com', 'SOCS', 'CAI', secure=True)  # accept all (required for mixes)
 516
 517     def _initialize_pref(self):
 518         cookies = self._get_cookies('https://www.youtube.com/')
 519         pref_cookie = cookies.get('PREF')
 520         pref = {}
 521         if pref_cookie:
 522             try:
 523                 pref = dict(urllib.parse.parse_qsl(pref_cookie.value))
 524             except ValueError:
 525                 self.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
 526         pref.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'})
 527         self._set_cookie('.youtube.com', name='PREF', value=urllib.parse.urlencode(pref))
 528
 529     def _real_initialize(self):
 530         self._initialize_pref()
 531         self._initialize_consent()
 532         self._check_login_required()
 533
 534     def _check_login_required(self):
 535         if self._LOGIN_REQUIRED and not self._cookies_passed:
 536             self.raise_login_required('Login details are needed to download this content', method='cookies')
 537
 538     _YT_INITIAL_DATA_RE = r'(?:window\s*\[\s*["\']ytInitialData["\']\s*\]|ytInitialData)\s*='
 539     _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
 540
 541     def _get_default_ytcfg(self, client='web'):
 542         return copy.deepcopy(INNERTUBE_CLIENTS[client])
 543
 544     def _get_innertube_host(self, client='web'):
 545         return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
 546
 547     def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
 548         # try_get but with fallback to default ytcfg client values when present
 549         _func = lambda y: try_get(y, getter, expected_type)
 550         return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
 551
 552     def _extract_client_name(self, ytcfg, default_client='web'):
 553         return self._ytcfg_get_safe(
 554             ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
 555                     lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
 556
 557     def _extract_client_version(self, ytcfg, default_client='web'):
 558         return self._ytcfg_get_safe(
 559             ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
 560                     lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
 561
 562     def _select_api_hostname(self, req_api_hostname, default_client=None):
 563         return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
 564                 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
 565
 566     def _extract_api_key(self, ytcfg=None, default_client='web'):
 567         return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
 568
 569     def _extract_context(self, ytcfg=None, default_client='web'):
 570         context = get_first(
 571             (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
 572         # Enforce language and tz for extraction
 573         client_context = traverse_obj(context, 'client', expected_type=dict, default={})
 574         client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
 575         return context
 576
 577     _SAPISID = None
 578
 579     def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
 580         time_now = round(time.time())
 581         if self._SAPISID is None:
 582             yt_cookies = self._get_cookies('https://www.youtube.com')
 583             # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
 584             # See: https://github.com/yt-dlp/yt-dlp/issues/393
 585             sapisid_cookie = dict_get(
 586                 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
 587             if sapisid_cookie and sapisid_cookie.value:
 588                 self._SAPISID = sapisid_cookie.value
 589                 self.write_debug('Extracted SAPISID cookie')
 590                 # SAPISID cookie is required if not already present
 591                 if not yt_cookies.get('SAPISID'):
 592                     self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
 593                     self._set_cookie(
 594                         '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
 595             else:
 596                 self._SAPISID = False
 597         if not self._SAPISID:
 598             return None
 599         # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
 600         sapisidhash = hashlib.sha1(
 601             f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
 602         return f'SAPISIDHASH {time_now}_{sapisidhash}'
 603
 604     def _call_api(self, ep, query, video_id, fatal=True, headers=None,
 605                   note='Downloading API JSON', errnote='Unable to download API page',
 606                   context=None, api_key=None, api_hostname=None, default_client='web'):
 607
 608         data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
 609         data.update(query)
 610         real_headers = self.generate_api_headers(default_client=default_client)
 611         real_headers.update({'content-type': 'application/json'})
 612         if headers:
 613             real_headers.update(headers)
 614         api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
 615                    or api_key or self._extract_api_key(default_client=default_client))
 616         return self._download_json(
 617             f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
 618             video_id=video_id, fatal=fatal, note=note, errnote=errnote,
 619             data=json.dumps(data).encode('utf8'), headers=real_headers,
 620             query={'key': api_key, 'prettyPrint': 'false'})
 621
 622     def extract_yt_initial_data(self, item_id, webpage, fatal=True):
 623         return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
 624
 625     @staticmethod
 626     def _extract_session_index(*data):
 627         """
 628         Index of current account in account list.
 629         See: https://github.com/yt-dlp/yt-dlp/pull/519
 630         """
 631         for ytcfg in data:
 632             session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
 633             if session_index is not None:
 634                 return session_index
 635
 636     # Deprecated?
 637     def _extract_identity_token(self, ytcfg=None, webpage=None):
 638         if ytcfg:
 639             token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
 640             if token:
 641                 return token
 642         if webpage:
 643             return self._search_regex(
 644                 r'\bID_TOKEN["\']\s*:\s*["\'](.+?)["\']', webpage,
 645                 'identity token', default=None, fatal=False)
 646
 647     @staticmethod
 648     def _extract_account_syncid(*args):
 649         """
 650         Extract syncId required to download private playlists of secondary channels
 651         @params response and/or ytcfg
 652         """
 653         for data in args:
 654             # ytcfg includes channel_syncid if on secondary channel
 655             delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID'], str)
 656             if delegated_sid:
 657                 return delegated_sid
 658             sync_ids = (try_get(
 659                 data, (lambda x: x['responseContext']['mainAppWebResponseContext']['datasyncId'],
 660                        lambda x: x['DATASYNC_ID']), str) or '').split('||')
 661             if len(sync_ids) >= 2 and sync_ids[1]:
 662                 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
 663                 # and just "user_syncid||" for primary channel. We only want the channel_syncid
 664                 return sync_ids[0]
 665
 666     @staticmethod
 667     def _extract_visitor_data(*args):
 668         """
 669         Extracts visitorData from an API response or ytcfg
 670         Appears to be used to track session state
 671         """
 672         return get_first(
 673             args, [('VISITOR_DATA', ('INNERTUBE_CONTEXT', 'client', 'visitorData'), ('responseContext', 'visitorData'))],
 674             expected_type=str)
 675
 676     @functools.cached_property
 677     def is_authenticated(self):
 678         return bool(self._generate_sapisidhash_header())
 679
 680     def extract_ytcfg(self, video_id, webpage):
 681         if not webpage:
 682             return {}
 683         return self._parse_json(
 684             self._search_regex(
 685                 r'ytcfg\.set\s*\(\s*({.+?})\s*\)\s*;', webpage, 'ytcfg',
 686                 default='{}'), video_id, fatal=False) or {}
 687
 688     def generate_api_headers(
 689             self, *, ytcfg=None, account_syncid=None, session_index=None,
 690             visitor_data=None, identity_token=None, api_hostname=None, default_client='web'):
 691
 692         origin = 'https://' + (self._select_api_hostname(api_hostname, default_client))
 693         headers = {
 694             'X-YouTube-Client-Name': str(
 695                 self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client=default_client)),
 696             'X-YouTube-Client-Version': self._extract_client_version(ytcfg, default_client),
 697             'Origin': origin,
 698             'X-Youtube-Identity-Token': identity_token or self._extract_identity_token(ytcfg),
 699             'X-Goog-PageId': account_syncid or self._extract_account_syncid(ytcfg),
 700             'X-Goog-Visitor-Id': visitor_data or self._extract_visitor_data(ytcfg),
 701             'User-Agent': self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CONTEXT']['client']['userAgent'], default_client=default_client),
 702         }
 703         if session_index is None:
 704             session_index = self._extract_session_index(ytcfg)
 705         if account_syncid or session_index is not None:
 706             headers['X-Goog-AuthUser'] = session_index if session_index is not None else 0
 707
 708         auth = self._generate_sapisidhash_header(origin)
 709         if auth is not None:
 710             headers['Authorization'] = auth
 711             headers['X-Origin'] = origin
 712         return filter_dict(headers)
 713
 714     def _download_ytcfg(self, client, video_id):
 715         url = {
 716             'web': 'https://www.youtube.com',
 717             'web_music': 'https://music.youtube.com',
 718             'web_embedded': f'https://www.youtube.com/embed/{video_id}?html5=1',
 719         }.get(client)
 720         if not url:
 721             return {}
 722         webpage = self._download_webpage(
 723             url, video_id, fatal=False, note=f'Downloading {client.replace("_", " ").strip()} client config')
 724         return self.extract_ytcfg(video_id, webpage) or {}
 725
 726     @staticmethod
 727     def _build_api_continuation_query(continuation, ctp=None):
 728         query = {
 729             'continuation': continuation,
 730         }
 731         # TODO: Inconsistency with clickTrackingParams.
 732         # Currently we have a fixed ctp contained within context (from ytcfg)
 733         # and a ctp in root query for continuation.
 734         if ctp:
 735             query['clickTracking'] = {'clickTrackingParams': ctp}
 736         return query
 737
 738     @classmethod
 739     def _extract_next_continuation_data(cls, renderer):
 740         next_continuation = try_get(
 741             renderer, (lambda x: x['continuations'][0]['nextContinuationData'],
 742                        lambda x: x['continuation']['reloadContinuationData']), dict)
 743         if not next_continuation:
 744             return
 745         continuation = next_continuation.get('continuation')
 746         if not continuation:
 747             return
 748         ctp = next_continuation.get('clickTrackingParams')
 749         return cls._build_api_continuation_query(continuation, ctp)
 750
 751     @classmethod
 752     def _extract_continuation_ep_data(cls, continuation_ep: dict):
 753         if isinstance(continuation_ep, dict):
 754             continuation = try_get(
 755                 continuation_ep, lambda x: x['continuationCommand']['token'], str)
 756             if not continuation:
 757                 return
 758             ctp = continuation_ep.get('clickTrackingParams')
 759             return cls._build_api_continuation_query(continuation, ctp)
 760
 761     @classmethod
 762     def _extract_continuation(cls, renderer):
 763         next_continuation = cls._extract_next_continuation_data(renderer)
 764         if next_continuation:
 765             return next_continuation
 766
 767         return traverse_obj(renderer, (
 768             ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
 769             ('continuationEndpoint', ('button', 'buttonRenderer', 'command')),
 770         ), get_all=False, expected_type=cls._extract_continuation_ep_data)
 771
 772     @classmethod
 773     def _extract_alerts(cls, data):
 774         for alert_dict in try_get(data, lambda x: x['alerts'], list) or []:
 775             if not isinstance(alert_dict, dict):
 776                 continue
 777             for alert in alert_dict.values():
 778                 alert_type = alert.get('type')
 779                 if not alert_type:
 780                     continue
 781                 message = cls._get_text(alert, 'text')
 782                 if message:
 783                     yield alert_type, message
 784
 785     def _report_alerts(self, alerts, expected=True, fatal=True, only_once=False):
 786         errors, warnings = [], []
 787         for alert_type, alert_message in alerts:
 788             if alert_type.lower() == 'error' and fatal:
 789                 errors.append([alert_type, alert_message])
 790             elif alert_message not in self._IGNORED_WARNINGS:
 791                 warnings.append([alert_type, alert_message])
 792
 793         for alert_type, alert_message in (warnings + errors[:-1]):
 794             self.report_warning(f'YouTube said: {alert_type} - {alert_message}', only_once=only_once)
 795         if errors:
 796             raise ExtractorError(f'YouTube said: {errors[-1][1]}', expected=expected)
 797
 798     def _extract_and_report_alerts(self, data, *args, **kwargs):
 799         return self._report_alerts(self._extract_alerts(data), *args, **kwargs)
 800
 801     def _extract_badges(self, badge_list: list):
 802         """
 803         Extract known BadgeType's from a list of badge renderers.
 804         @returns [{'type': BadgeType}]
 805         """
 806         icon_type_map = {
 807             'PRIVACY_UNLISTED': BadgeType.AVAILABILITY_UNLISTED,
 808             'PRIVACY_PRIVATE': BadgeType.AVAILABILITY_PRIVATE,
 809             'PRIVACY_PUBLIC': BadgeType.AVAILABILITY_PUBLIC,
 810             'CHECK_CIRCLE_THICK': BadgeType.VERIFIED,
 811             'OFFICIAL_ARTIST_BADGE': BadgeType.VERIFIED,
 812             'CHECK': BadgeType.VERIFIED,
 813         }
 814
 815         badge_style_map = {
 816             'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType.AVAILABILITY_SUBSCRIPTION,
 817             'BADGE_STYLE_TYPE_PREMIUM': BadgeType.AVAILABILITY_PREMIUM,
 818             'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType.LIVE_NOW,
 819             'BADGE_STYLE_TYPE_VERIFIED': BadgeType.VERIFIED,
 820             'BADGE_STYLE_TYPE_VERIFIED_ARTIST': BadgeType.VERIFIED,
 821         }
 822
 823         label_map = {
 824             'unlisted': BadgeType.AVAILABILITY_UNLISTED,
 825             'private': BadgeType.AVAILABILITY_PRIVATE,
 826             'members only': BadgeType.AVAILABILITY_SUBSCRIPTION,
 827             'live': BadgeType.LIVE_NOW,
 828             'premium': BadgeType.AVAILABILITY_PREMIUM,
 829             'verified': BadgeType.VERIFIED,
 830             'official artist channel': BadgeType.VERIFIED,
 831         }
 832
 833         badges = []
 834         for badge in traverse_obj(badge_list, (..., lambda key, _: re.search(r'[bB]adgeRenderer$', key))):
 835             badge_type = (
 836                 icon_type_map.get(traverse_obj(badge, ('icon', 'iconType'), expected_type=str))
 837                 or badge_style_map.get(traverse_obj(badge, 'style'))
 838             )
 839             if badge_type:
 840                 badges.append({'type': badge_type})
 841                 continue
 842
 843             # fallback, won't work in some languages
 844             label = traverse_obj(
 845                 badge, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all=False, expected_type=str, default='')
 846             for match, label_badge_type in label_map.items():
 847                 if match in label.lower():
 848                     badges.append({'type': label_badge_type})
 849                     break
 850
 851         return badges
 852
 853     @staticmethod
 854     def _has_badge(badges, badge_type):
 855         return bool(traverse_obj(badges, lambda _, v: v['type'] == badge_type))
 856
 857     @staticmethod
 858     def _get_text(data, *path_list, max_runs=None):
 859         for path in path_list or [None]:
 860             if path is None:
 861                 obj = [data]
 862             else:
 863                 obj = traverse_obj(data, path, default=[])
 864                 if not any(key is ... or isinstance(key, (list, tuple)) for key in variadic(path)):
 865                     obj = [obj]
 866             for item in obj:
 867                 text = try_get(item, lambda x: x['simpleText'], str)
 868                 if text:
 869                     return text
 870                 runs = try_get(item, lambda x: x['runs'], list) or []
 871                 if not runs and isinstance(item, list):
 872                     runs = item
 873
 874                 runs = runs[:min(len(runs), max_runs or len(runs))]
 875                 text = ''.join(traverse_obj(runs, (..., 'text'), expected_type=str))
 876                 if text:
 877                     return text
 878
 879     def _get_count(self, data, *path_list):
 880         count_text = self._get_text(data, *path_list) or ''
 881         count = parse_count(count_text)
 882         if count is None:
 883             count = str_to_int(
 884                 self._search_regex(r'^([\d,]+)', re.sub(r'\s', '', count_text), 'count', default=None))
 885         return count
 886
 887     @staticmethod
 888     def _extract_thumbnails(data, *path_list, final_key='thumbnails'):
 889         """
 890         Extract thumbnails from thumbnails dict
 891         @param path_list: path list to level that contains 'thumbnails' key
 892         """
 893         thumbnails = []
 894         for path in path_list or [()]:
 895             for thumbnail in traverse_obj(data, (*variadic(path), final_key, ...)):
 896                 thumbnail_url = url_or_none(thumbnail.get('url'))
 897                 if not thumbnail_url:
 898                     continue
 899                 # Sometimes youtube gives a wrong thumbnail URL. See:
 900                 # https://github.com/yt-dlp/yt-dlp/issues/233
 901                 # https://github.com/ytdl-org/youtube-dl/issues/28023
 902                 if 'maxresdefault' in thumbnail_url:
 903                     thumbnail_url = thumbnail_url.split('?')[0]
 904                 thumbnails.append({
 905                     'url': thumbnail_url,
 906                     'height': int_or_none(thumbnail.get('height')),
 907                     'width': int_or_none(thumbnail.get('width')),
 908                 })
 909         return thumbnails
 910
 911     @staticmethod
 912     def extract_relative_time(relative_time_text):
 913         """
 914         Extracts a relative time from string and converts to dt object
 915         e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
 916         """
 917
 918         # XXX: this could be moved to a general function in utils/_utils.py
 919         # The relative time text strings are roughly the same as what
 920         # Javascript's Intl.RelativeTimeFormat function generates.
 921         # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
 922         mobj = re.search(
 923             r'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
 924             relative_time_text)
 925         if mobj:
 926             start = mobj.group('start')
 927             if start:
 928                 return datetime_from_str(start)
 929             try:
 930                 return datetime_from_str('now-{}{}'.format(mobj.group('time'), mobj.group('unit')))
 931             except ValueError:
 932                 return None
 933
 934     def _parse_time_text(self, text):
 935         if not text:
 936             return
 937         dt_ = self.extract_relative_time(text)
 938         timestamp = None
 939         if isinstance(dt_, dt.datetime):
 940             timestamp = calendar.timegm(dt_.timetuple())
 941
 942         if timestamp is None:
 943             timestamp = (
 944                 unified_timestamp(text) or unified_timestamp(
 945                     self._search_regex(
 946                         (r'([a-z]+\s*\d{1,2},?\s*20\d{2})', r'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
 947                         text.lower(), 'time text', default=None)))
 948
 949         if text and timestamp is None and self._preferred_lang in (None, 'en'):
 950             self.report_warning(
 951                 f'Cannot parse localized time text "{text}"', only_once=True)
 952         return timestamp
 953
 954     def _extract_response(self, item_id, query, note='Downloading API JSON', headers=None,
 955                           ytcfg=None, check_get_keys=None, ep='browse', fatal=True, api_hostname=None,
 956                           default_client='web'):
 957         raise_for_incomplete = bool(self._configuration_arg('raise_incomplete_data', ie_key=YoutubeIE))
 958         # Incomplete Data should be a warning by default when retries are exhausted, while other errors should be fatal.
 959         icd_retries = iter(self.RetryManager(fatal=raise_for_incomplete))
 960         icd_rm = next(icd_retries)
 961         main_retries = iter(self.RetryManager())
 962         main_rm = next(main_retries)
 963         # Manual retry loop for multiple RetryManagers
 964         # The proper RetryManager MUST be advanced after an error
 965         # and its result MUST be checked if the manager is non fatal
 966         while True:
 967             try:
 968                 response = self._call_api(
 969                     ep=ep, fatal=True, headers=headers,
 970                     video_id=item_id, query=query, note=note,
 971                     context=self._extract_context(ytcfg, default_client),
 972                     api_key=self._extract_api_key(ytcfg, default_client),
 973                     api_hostname=api_hostname, default_client=default_client)
 974             except ExtractorError as e:
 975                 if not isinstance(e.cause, network_exceptions):
 976                     return self._error_or_warning(e, fatal=fatal)
 977                 elif not isinstance(e.cause, HTTPError):
 978                     main_rm.error = e
 979                     next(main_retries)
 980                     continue
 981
 982                 first_bytes = e.cause.response.read(512)
 983                 if not is_html(first_bytes):
 984                     yt_error = try_get(
 985                         self._parse_json(
 986                             self._webpage_read_content(e.cause.response, None, item_id, prefix=first_bytes) or '{}', item_id, fatal=False),
 987                         lambda x: x['error']['message'], str)
 988                     if yt_error:
 989                         self._report_alerts([('ERROR', yt_error)], fatal=False)
 990                 # Downloading page may result in intermittent 5xx HTTP error
 991                 # Sometimes a 404 is also received. See: https://github.com/ytdl-org/youtube-dl/issues/28289
 992                 # We also want to catch all other network exceptions since errors in later pages can be troublesome
 993                 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
 994                 if e.cause.status not in (403, 429):
 995                     main_rm.error = e
 996                     next(main_retries)
 997                     continue
 998                 return self._error_or_warning(e, fatal=fatal)
 999
1000             try:
1001                 self._extract_and_report_alerts(response, only_once=True)
1002             except ExtractorError as e:
1003                 # YouTube's servers may return errors we want to retry on in a 200 OK response
1004                 # See: https://github.com/yt-dlp/yt-dlp/issues/839
1005                 if 'unknown error' in e.msg.lower():
1006                     main_rm.error = e
1007                     next(main_retries)
1008                     continue
1009                 return self._error_or_warning(e, fatal=fatal)
1010             # Youtube sometimes sends incomplete data
1011             # See: https://github.com/ytdl-org/youtube-dl/issues/28194
1012             if not traverse_obj(response, *variadic(check_get_keys)):
1013                 icd_rm.error = ExtractorError('Incomplete data received', expected=True)
1014                 should_retry = next(icd_retries, None)
1015                 if not should_retry:
1016                     return None
1017                 continue
1018
1019             return response
1020
1021     @staticmethod
1022     def is_music_url(url):
1023         return re.match(r'(https?://)?music\.youtube\.com/', url) is not None
1024
1025     def _extract_video(self, renderer):
1026         video_id = renderer.get('videoId')
1027
1028         reel_header_renderer = traverse_obj(renderer, (
1029             'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1030             'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1031
1032         title = self._get_text(renderer, 'title', 'headline') or self._get_text(reel_header_renderer, 'reelTitleText')
1033         description = self._get_text(renderer, 'descriptionSnippet')
1034
1035         duration = int_or_none(renderer.get('lengthSeconds'))
1036         if duration is None:
1037             duration = parse_duration(self._get_text(
1038                 renderer, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1039         if duration is None:
1040             # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1041             duration = parse_duration(self._search_regex(
1042                 r'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1043                 traverse_obj(renderer, ('title', 'accessibility', 'accessibilityData', 'label'), default='', expected_type=str),
1044                 video_id, default=None, group='duration'))
1045
1046         channel_id = traverse_obj(
1047             renderer, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1048             expected_type=str, get_all=False)
1049         if not channel_id:
1050             channel_id = traverse_obj(reel_header_renderer, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1051
1052         channel_id = self.ucid_or_none(channel_id)
1053
1054         overlay_style = traverse_obj(
1055             renderer, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1056             get_all=False, expected_type=str)
1057         badges = self._extract_badges(traverse_obj(renderer, 'badges'))
1058         owner_badges = self._extract_badges(traverse_obj(renderer, 'ownerBadges'))
1059         navigation_url = urljoin('https://www.youtube.com/', traverse_obj(
1060             renderer, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1061             expected_type=str)) or ''
1062         url = f'https://www.youtube.com/watch?v={video_id}'
1063         if overlay_style == 'SHORTS' or '/shorts/' in navigation_url:
1064             url = f'https://www.youtube.com/shorts/{video_id}'
1065
1066         time_text = (self._get_text(renderer, 'publishedTimeText', 'videoInfo')
1067                      or self._get_text(reel_header_renderer, 'timestampText') or '')
1068         scheduled_timestamp = str_to_int(traverse_obj(renderer, ('upcomingEventData', 'startTime'), get_all=False))
1069
1070         live_status = (
1071             'is_upcoming' if scheduled_timestamp is not None
1072             else 'was_live' if 'streamed' in time_text.lower()
1073             else 'is_live' if overlay_style == 'LIVE' or self._has_badge(badges, BadgeType.LIVE_NOW)
1074             else None)
1075
1076         # videoInfo is a string like '50K views • 10 years ago'.
1077         view_count_text = self._get_text(renderer, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1078         view_count = (0 if 'no views' in view_count_text.lower()
1079                       else self._get_count({'simpleText': view_count_text}))
1080         view_count_field = 'concurrent_view_count' if live_status in ('is_live', 'is_upcoming') else 'view_count'
1081
1082         channel = (self._get_text(renderer, 'ownerText', 'shortBylineText')
1083                    or self._get_text(reel_header_renderer, 'channelTitleText'))
1084
1085         channel_handle = traverse_obj(renderer, (
1086             'shortBylineText', 'runs', ..., 'navigationEndpoint',
1087             (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1088             expected_type=self.handle_from_url, get_all=False)
1089         return {
1090             '_type': 'url',
1091             'ie_key': YoutubeIE.ie_key(),
1092             'id': video_id,
1093             'url': url,
1094             'title': title,
1095             'description': description,
1096             'duration': duration,
1097             'channel_id': channel_id,
1098             'channel': channel,
1099             'channel_url': f'https://www.youtube.com/channel/{channel_id}' if channel_id else None,
1100             'uploader': channel,
1101             'uploader_id': channel_handle,
1102             'uploader_url': format_field(channel_handle, None, 'https://www.youtube.com/%s', default=None),
1103             'thumbnails': self._extract_thumbnails(renderer, 'thumbnail'),
1104             'timestamp': (self._parse_time_text(time_text)
1105                           if self._configuration_arg('approximate_date', ie_key=YoutubeTabIE)
1106                           else None),
1107             'release_timestamp': scheduled_timestamp,
1108             'availability':
1109                 'public' if self._has_badge(badges, BadgeType.AVAILABILITY_PUBLIC)
1110                 else self._availability(
1111                     is_private=self._has_badge(badges, BadgeType.AVAILABILITY_PRIVATE) or None,
1112                     needs_premium=self._has_badge(badges, BadgeType.AVAILABILITY_PREMIUM) or None,
1113                     needs_subscription=self._has_badge(badges, BadgeType.AVAILABILITY_SUBSCRIPTION) or None,
1114                     is_unlisted=self._has_badge(badges, BadgeType.AVAILABILITY_UNLISTED) or None),
1115             view_count_field: view_count,
1116             'live_status': live_status,
1117             'channel_is_verified': True if self._has_badge(owner_badges, BadgeType.VERIFIED) else None,
1118         }
1119
1120
1121 class YoutubeIE(YoutubeBaseInfoExtractor):
1122     IE_DESC = 'YouTube'
1123     _VALID_URL = r'''(?x)^
1124                      (
1125                          (?:https?://|//)                                    # http(s):// or protocol-independent URL
1126                          (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1127                             (?:www\.)?deturl\.com/www\.youtube\.com|
1128                             (?:www\.)?pwnyoutube\.com|
1129                             (?:www\.)?hooktube\.com|
1130                             (?:www\.)?yourepeat\.com|
1131                             tube\.majestyc\.net|
1132                             {invidious}|
1133                             youtube\.googleapis\.com)/                        # the various hostnames, with wildcard subdomains
1134                          (?:.*?\#/)?                                          # handle anchor (#/) redirect urls
1135                          (?:                                                  # the various things that can precede the ID:
1136                              (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream))  # v/ or embed/ or e/ or shorts/
1137                              |(?:                                             # or the v= param in all its forms
1138                                  (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)?  # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1139                                  (?:\?|\#!?)                                  # the params delimiter ? or # or #!
1140                                  (?:.*?[&;])??                                # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&amp;v=V36LpHqtcDY)
1141                                  v=
1142                              )
1143                          ))
1144                          |(?:
1145                             youtu\.be|                                        # just youtu.be/xxxx
1146                             vid\.plus|                                        # or vid.plus/xxxx
1147                             zwearz\.com/watch|                                # or zwearz.com/watch/xxxx
1148                             {invidious}
1149                          )/
1150                          |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1151                          )
1152                      )?                                                       # all until now is optional -> you can pass the naked ID
1153                      (?P<id>[0-9A-Za-z_-]{{11}})                              # here is it! the YouTube video ID
1154                      (?(1).+)?                                                # if we found the ID, everything can follow
1155                      (?:\#|$)'''.format(
1156         invidious='|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
1157     )
1158     _EMBED_REGEX = [
1159         r'''(?x)
1160             (?:
1161                 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1162                 data-video-url=|
1163                 <embed[^>]+?src=|
1164                 embedSWF\(?:\s*|
1165                 <object[^>]+data=|
1166                 new\s+SWFObject\(
1167             )
1168             (["\'])
1169                 (?P<url>(?:https?:)?//(?:www\.)?youtube(?:-nocookie)?\.com/
1170                 (?:embed|v|p)/[0-9A-Za-z_-]{11}.*?)
1171             \1''',
1172         # https://wordpress.org/plugins/lazy-load-for-videos/
1173         r'''(?xs)
1174             <a\s[^>]*\bhref="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1175             \s[^>]*\bclass="[^"]*\blazy-load-youtube''',
1176     ]
1177     _RETURN_TYPE = 'video'  # XXX: How to handle multifeed?
1178
1179     _PLAYER_INFO_RE = (
1180         r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1181         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$',
1182         r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1183     )
1184     _formats = {  # NB: Used in YoutubeWebArchiveIE and GoogleDriveIE
1185         '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1186         '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1187         '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1188         '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1189         '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1190         '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1191         '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1192         '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1193         # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1194         '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1195         '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1196         '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1197         '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1198         '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1199         '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1200         '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1201         '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1202         '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1203
1204
1205         # 3D videos
1206         '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1207         '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1208         '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1209         '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1210         '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1211         '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1212         '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1213
1214         # Apple HTTP Live Streaming
1215         '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1216         '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1217         '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1218         '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1219         '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1220         '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1221         '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1222         '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1223
1224         # DASH mp4 video
1225         '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1226         '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1227         '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1228         '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1229         '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1230         '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'},  # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1231         '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1232         '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1233         '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1234         '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1235         '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1236         '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1237
1238         # Dash mp4 audio
1239         '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1240         '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1241         '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1242         '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1243         '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1244         '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1245         '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1246
1247         # Dash webm
1248         '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1249         '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1250         '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1251         '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1252         '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1253         '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1254         '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1255         '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1256         '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1257         '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1258         '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1259         '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1260         '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1261         '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1262         '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1263         # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1264         '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1265         '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1266         '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1267         '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1268         '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1269         '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1270
1271         # Dash webm audio
1272         '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1273         '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1274
1275         # Dash webm audio with opus inside
1276         '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1277         '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1278         '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1279
1280         # RTMP (unnamed)
1281         '_rtmp': {'protocol': 'rtmp'},
1282
1283         # av01 video only formats sometimes served with "unknown" codecs
1284         '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1285         '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1286         '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1287         '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1288         '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1289         '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1290         '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1291         '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1292     }
1293     _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1294
1295     _GEO_BYPASS = False
1296
1297     IE_NAME = 'youtube'
1298     _TESTS = [
1299         {
1300             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1301             'info_dict': {
1302                 'id': 'BaW_jenozKc',
1303                 'ext': 'mp4',
1304                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1305                 'channel': 'Philipp Hagemeister',
1306                 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1307                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1308                 'upload_date': '20121002',
1309                 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1310                 'categories': ['Science & Technology'],
1311                 'tags': ['youtube-dl'],
1312                 'duration': 10,
1313                 'view_count': int,
1314                 'like_count': int,
1315                 'availability': 'public',
1316                 'playable_in_embed': True,
1317                 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1318                 'live_status': 'not_live',
1319                 'age_limit': 0,
1320                 'start_time': 1,
1321                 'end_time': 9,
1322                 'comment_count': int,
1323                 'channel_follower_count': int,
1324                 'uploader': 'Philipp Hagemeister',
1325                 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1326                 'uploader_id': '@PhilippHagemeister',
1327                 'heatmap': 'count:100',
1328                 'timestamp': 1349198244,
1329             },
1330         },
1331         {
1332             'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1333             'note': 'Embed-only video (#1746)',
1334             'info_dict': {
1335                 'id': 'yZIXLfi8CZQ',
1336                 'ext': 'mp4',
1337                 'upload_date': '20120608',
1338                 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1339                 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1340                 'age_limit': 18,
1341             },
1342             'skip': 'Private video',
1343         },
1344         {
1345             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1346             'note': 'Use the first video ID in the URL',
1347             'info_dict': {
1348                 'id': 'BaW_jenozKc',
1349                 'ext': 'mp4',
1350                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1351                 'channel': 'Philipp Hagemeister',
1352                 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1353                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1354                 'upload_date': '20121002',
1355                 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1356                 'categories': ['Science & Technology'],
1357                 'tags': ['youtube-dl'],
1358                 'duration': 10,
1359                 'view_count': int,
1360                 'like_count': int,
1361                 'availability': 'public',
1362                 'playable_in_embed': True,
1363                 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1364                 'live_status': 'not_live',
1365                 'age_limit': 0,
1366                 'comment_count': int,
1367                 'channel_follower_count': int,
1368                 'uploader': 'Philipp Hagemeister',
1369                 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1370                 'uploader_id': '@PhilippHagemeister',
1371                 'heatmap': 'count:100',
1372                 'timestamp': 1349198244,
1373             },
1374             'params': {
1375                 'skip_download': True,
1376             },
1377         },
1378         {
1379             'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1380             'note': '256k DASH audio (format 141) via DASH manifest',
1381             'info_dict': {
1382                 'id': 'a9LDPn-MO4I',
1383                 'ext': 'm4a',
1384                 'upload_date': '20121002',
1385                 'description': '',
1386                 'title': 'UHDTV TEST 8K VIDEO.mp4',
1387             },
1388             'params': {
1389                 'youtube_include_dash_manifest': True,
1390                 'format': '141',
1391             },
1392             'skip': 'format 141 not served anymore',
1393         },
1394         # DASH manifest with encrypted signature
1395         {
1396             'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1397             'info_dict': {
1398                 'id': 'IB3lcPjvWLA',
1399                 'ext': 'm4a',
1400                 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1401                 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1402                 'duration': 244,
1403                 'upload_date': '20131011',
1404                 'abr': 129.495,
1405                 'like_count': int,
1406                 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1407                 'playable_in_embed': True,
1408                 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1409                 'view_count': int,
1410                 'track': 'The Spark',
1411                 'live_status': 'not_live',
1412                 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1413                 'channel': 'Afrojack',
1414                 'tags': 'count:19',
1415                 'availability': 'public',
1416                 'categories': ['Music'],
1417                 'age_limit': 0,
1418                 'alt_title': 'The Spark',
1419                 'channel_follower_count': int,
1420                 'uploader': 'Afrojack',
1421                 'uploader_url': 'https://www.youtube.com/@Afrojack',
1422                 'uploader_id': '@Afrojack',
1423             },
1424             'params': {
1425                 'youtube_include_dash_manifest': True,
1426                 'format': '141/bestaudio[ext=m4a]',
1427             },
1428         },
1429         # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1430         {
1431             'note': 'Embed allowed age-gate video',
1432             'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1433             'info_dict': {
1434                 'id': 'HtVdAasjOgU',
1435                 'ext': 'mp4',
1436                 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1437                 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1438                 'duration': 142,
1439                 'upload_date': '20140605',
1440                 'age_limit': 18,
1441                 'categories': ['Gaming'],
1442                 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1443                 'availability': 'needs_auth',
1444                 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1445                 'like_count': int,
1446                 'channel': 'The Witcher',
1447                 'live_status': 'not_live',
1448                 'tags': 'count:17',
1449                 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1450                 'playable_in_embed': True,
1451                 'view_count': int,
1452                 'channel_follower_count': int,
1453                 'uploader': 'The Witcher',
1454                 'uploader_url': 'https://www.youtube.com/@thewitcher',
1455                 'uploader_id': '@thewitcher',
1456                 'comment_count': int,
1457                 'channel_is_verified': True,
1458                 'heatmap': 'count:100',
1459                 'timestamp': 1401991663,
1460             },
1461         },
1462         {
1463             'note': 'Age-gate video with embed allowed in public site',
1464             'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1465             'info_dict': {
1466                 'id': 'HsUATh_Nc2U',
1467                 'ext': 'mp4',
1468                 'title': 'Godzilla 2 (Official Video)',
1469                 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1470                 'upload_date': '20200408',
1471                 'age_limit': 18,
1472                 'availability': 'needs_auth',
1473                 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1474                 'channel': 'FlyingKitty',
1475                 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1476                 'view_count': int,
1477                 'categories': ['Entertainment'],
1478                 'live_status': 'not_live',
1479                 'tags': ['Flyingkitty', 'godzilla 2'],
1480                 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1481                 'like_count': int,
1482                 'duration': 177,
1483                 'playable_in_embed': True,
1484                 'channel_follower_count': int,
1485                 'uploader': 'FlyingKitty',
1486                 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1487                 'uploader_id': '@FlyingKitty900',
1488                 'comment_count': int,
1489                 'channel_is_verified': True,
1490             },
1491         },
1492         {
1493             'note': 'Age-gate video embedable only with clientScreen=EMBED',
1494             'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1495             'info_dict': {
1496                 'id': 'Tq92D6wQ1mg',
1497                 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1498                 'ext': 'mp4',
1499                 'upload_date': '20191228',
1500                 'description': 'md5:17eccca93a786d51bc67646756894066',
1501                 'age_limit': 18,
1502                 'like_count': int,
1503                 'availability': 'needs_auth',
1504                 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1505                 'view_count': int,
1506                 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1507                 'channel': 'Projekt Melody',
1508                 'live_status': 'not_live',
1509                 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1510                 'playable_in_embed': True,
1511                 'categories': ['Entertainment'],
1512                 'duration': 106,
1513                 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1514                 'comment_count': int,
1515                 'channel_follower_count': int,
1516                 'uploader': 'Projekt Melody',
1517                 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1518                 'uploader_id': '@ProjektMelody',
1519                 'timestamp': 1577508724,
1520             },
1521         },
1522         {
1523             'note': 'Non-Agegated non-embeddable video',
1524             'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1525             'info_dict': {
1526                 'id': 'MeJVWBSsPAY',
1527                 'ext': 'mp4',
1528                 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1529                 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1530                 'upload_date': '20130730',
1531                 'track': 'Such mich find mich',
1532                 'age_limit': 0,
1533                 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1534                 'like_count': int,
1535                 'playable_in_embed': False,
1536                 'creator': 'OOMPH!',
1537                 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1538                 'view_count': int,
1539                 'alt_title': 'Such mich find mich',
1540                 'duration': 210,
1541                 'channel': 'Herr Lurik',
1542                 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1543                 'categories': ['Music'],
1544                 'availability': 'public',
1545                 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1546                 'live_status': 'not_live',
1547                 'artist': 'OOMPH!',
1548                 'channel_follower_count': int,
1549                 'uploader': 'Herr Lurik',
1550                 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1551                 'uploader_id': '@HerrLurik',
1552             },
1553         },
1554         {
1555             'note': 'Non-bypassable age-gated video',
1556             'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1557             'only_matching': True,
1558         },
1559         # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1560         # YouTube Red ad is not captured for creator
1561         {
1562             'url': '__2ABJjxzNo',
1563             'info_dict': {
1564                 'id': '__2ABJjxzNo',
1565                 'ext': 'mp4',
1566                 'duration': 266,
1567                 'upload_date': '20100430',
1568                 'creator': 'deadmau5',
1569                 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1570                 'title': 'Deadmau5 - Some Chords (HD)',
1571                 'alt_title': 'Some Chords',
1572                 'availability': 'public',
1573                 'tags': 'count:14',
1574                 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1575                 'view_count': int,
1576                 'live_status': 'not_live',
1577                 'channel': 'deadmau5',
1578                 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1579                 'like_count': int,
1580                 'track': 'Some Chords',
1581                 'artist': 'deadmau5',
1582                 'playable_in_embed': True,
1583                 'age_limit': 0,
1584                 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1585                 'categories': ['Music'],
1586                 'album': 'Some Chords',
1587                 'channel_follower_count': int,
1588                 'uploader': 'deadmau5',
1589                 'uploader_url': 'https://www.youtube.com/@deadmau5',
1590                 'uploader_id': '@deadmau5',
1591             },
1592             'expected_warnings': [
1593                 'DASH manifest missing',
1594             ],
1595         },
1596         # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1597         {
1598             'url': 'lqQg6PlCWgI',
1599             'info_dict': {
1600                 'id': 'lqQg6PlCWgI',
1601                 'ext': 'mp4',
1602                 'duration': 6085,
1603                 'upload_date': '20150827',
1604                 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1605                 'title': 'Hockey - Women -  GER-AUS - London 2012 Olympic Games',
1606                 'like_count': int,
1607                 'release_timestamp': 1343767800,
1608                 'playable_in_embed': True,
1609                 'categories': ['Sports'],
1610                 'release_date': '20120731',
1611                 'channel': 'Olympics',
1612                 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1613                 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1614                 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1615                 'age_limit': 0,
1616                 'availability': 'public',
1617                 'live_status': 'was_live',
1618                 'view_count': int,
1619                 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1620                 'channel_follower_count': int,
1621                 'uploader': 'Olympics',
1622                 'uploader_url': 'https://www.youtube.com/@Olympics',
1623                 'uploader_id': '@Olympics',
1624                 'channel_is_verified': True,
1625                 'timestamp': 1440707674,
1626             },
1627             'params': {
1628                 'skip_download': 'requires avconv',
1629             },
1630         },
1631         # Non-square pixels
1632         {
1633             'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1634             'info_dict': {
1635                 'id': '_b-2C3KPAM0',
1636                 'ext': 'mp4',
1637                 'stretched_ratio': 16 / 9.,
1638                 'duration': 85,
1639                 'upload_date': '20110310',
1640                 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1641                 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1642                 'playable_in_embed': True,
1643                 'channel': '孫ᄋᄅ',
1644                 'age_limit': 0,
1645                 'tags': 'count:11',
1646                 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1647                 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1648                 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1649                 'view_count': int,
1650                 'categories': ['People & Blogs'],
1651                 'like_count': int,
1652                 'live_status': 'not_live',
1653                 'availability': 'unlisted',
1654                 'comment_count': int,
1655                 'channel_follower_count': int,
1656                 'uploader': '孫ᄋᄅ',
1657                 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1658                 'uploader_id': '@AllenMeow',
1659                 'timestamp': 1299776999,
1660             },
1661         },
1662         # url_encoded_fmt_stream_map is empty string
1663         {
1664             'url': 'qEJwOuvDf7I',
1665             'info_dict': {
1666                 'id': 'qEJwOuvDf7I',
1667                 'ext': 'webm',
1668                 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1669                 'description': '',
1670                 'upload_date': '20150404',
1671             },
1672             'params': {
1673                 'skip_download': 'requires avconv',
1674             },
1675             'skip': 'This live event has ended.',
1676         },
1677         # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1678         {
1679             'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1680             'info_dict': {
1681                 'id': 'FIl7x6_3R5Y',
1682                 'ext': 'webm',
1683                 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1684                 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1685                 'duration': 220,
1686                 'upload_date': '20150625',
1687                 'formats': 'mincount:31',
1688             },
1689             'skip': 'not actual anymore',
1690         },
1691         # DASH manifest with segment_list
1692         {
1693             'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1694             'md5': '8ce563a1d667b599d21064e982ab9e31',
1695             'info_dict': {
1696                 'id': 'CsmdDsKjzN8',
1697                 'ext': 'mp4',
1698                 'upload_date': '20150501',  # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1699                 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1700                 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1701             },
1702             'params': {
1703                 'youtube_include_dash_manifest': True,
1704                 'format': '135',  # bestvideo
1705             },
1706             'skip': 'This live event has ended.',
1707         },
1708         {
1709             # Multifeed videos (multiple cameras), URL can be of any Camera
1710             # TODO: fix multifeed titles
1711             'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1712             'info_dict': {
1713                 'id': 'zaPI8MvL8pg',
1714                 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1715                 'description': 'md5:563ccbc698b39298481ca3c571169519',
1716             },
1717             'playlist': [{
1718                 'info_dict': {
1719                     'id': 'j5yGuxZ8lLU',
1720                     'ext': 'mp4',
1721                     'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1722                     'description': 'md5:563ccbc698b39298481ca3c571169519',
1723                     'duration': 10120,
1724                     'channel_follower_count': int,
1725                     'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1726                     'availability': 'public',
1727                     'playable_in_embed': True,
1728                     'upload_date': '20131105',
1729                     'categories': ['Gaming'],
1730                     'live_status': 'was_live',
1731                     'tags': 'count:24',
1732                     'release_timestamp': 1383701910,
1733                     'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1734                     'comment_count': int,
1735                     'age_limit': 0,
1736                     'like_count': int,
1737                     'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1738                     'channel': 'WiiLikeToPlay',
1739                     'view_count': int,
1740                     'release_date': '20131106',
1741                     'uploader': 'WiiLikeToPlay',
1742                     'uploader_id': '@WLTP',
1743                     'uploader_url': 'https://www.youtube.com/@WLTP',
1744                 },
1745             }, {
1746                 'info_dict': {
1747                     'id': 'zaPI8MvL8pg',
1748                     'ext': 'mp4',
1749                     'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1750                     'availability': 'public',
1751                     'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1752                     'channel': 'WiiLikeToPlay',
1753                     'channel_follower_count': int,
1754                     'description': 'md5:563ccbc698b39298481ca3c571169519',
1755                     'duration': 10108,
1756                     'age_limit': 0,
1757                     'like_count': int,
1758                     'tags': 'count:24',
1759                     'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1760                     'release_timestamp': 1383701915,
1761                     'comment_count': int,
1762                     'upload_date': '20131105',
1763                     'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1764                     'release_date': '20131106',
1765                     'playable_in_embed': True,
1766                     'live_status': 'was_live',
1767                     'categories': ['Gaming'],
1768                     'view_count': int,
1769                     'uploader': 'WiiLikeToPlay',
1770                     'uploader_id': '@WLTP',
1771                     'uploader_url': 'https://www.youtube.com/@WLTP',
1772                 },
1773             }, {
1774                 'info_dict': {
1775                     'id': 'R7r3vfO7Hao',
1776                     'ext': 'mp4',
1777                     'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1778                     'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1779                     'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1780                     'like_count': int,
1781                     'availability': 'public',
1782                     'playable_in_embed': True,
1783                     'upload_date': '20131105',
1784                     'description': 'md5:563ccbc698b39298481ca3c571169519',
1785                     'channel_follower_count': int,
1786                     'tags': 'count:24',
1787                     'release_date': '20131106',
1788                     'comment_count': int,
1789                     'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1790                     'channel': 'WiiLikeToPlay',
1791                     'categories': ['Gaming'],
1792                     'release_timestamp': 1383701914,
1793                     'live_status': 'was_live',
1794                     'age_limit': 0,
1795                     'duration': 10128,
1796                     'view_count': int,
1797                     'uploader': 'WiiLikeToPlay',
1798                     'uploader_id': '@WLTP',
1799                     'uploader_url': 'https://www.youtube.com/@WLTP',
1800                 },
1801             }],
1802             'params': {'skip_download': True},
1803             'skip': 'Not multifeed anymore',
1804         },
1805         {
1806             # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1807             'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1808             'info_dict': {
1809                 'id': 'gVfLd0zydlo',
1810                 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1811             },
1812             'playlist_count': 2,
1813             'skip': 'Not multifeed anymore',
1814         },
1815         {
1816             'url': 'https://vid.plus/FlRa-iH7PGw',
1817             'only_matching': True,
1818         },
1819         {
1820             'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1821             'only_matching': True,
1822         },
1823         {
1824             # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1825             # Also tests cut-off URL expansion in video description (see
1826             # https://github.com/ytdl-org/youtube-dl/issues/1892,
1827             # https://github.com/ytdl-org/youtube-dl/issues/8164)
1828             'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1829             'info_dict': {
1830                 'id': 'lsguqyKfVQg',
1831                 'ext': 'mp4',
1832                 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1833                 'alt_title': 'Dark Walk',
1834                 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1835                 'duration': 133,
1836                 'upload_date': '20151119',
1837                 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1838                 'track': 'Dark Walk',
1839                 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1840                 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1841                 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1842                 'categories': ['Film & Animation'],
1843                 'view_count': int,
1844                 'live_status': 'not_live',
1845                 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1846                 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1847                 'tags': 'count:13',
1848                 'availability': 'public',
1849                 'channel': 'IronSoulElf',
1850                 'playable_in_embed': True,
1851                 'like_count': int,
1852                 'age_limit': 0,
1853                 'channel_follower_count': int,
1854             },
1855             'params': {
1856                 'skip_download': True,
1857             },
1858         },
1859         {
1860             # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1861             'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1862             'only_matching': True,
1863         },
1864         {
1865             # Video with yt:stretch=17:0
1866             'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1867             'info_dict': {
1868                 'id': 'Q39EVAstoRM',
1869                 'ext': 'mp4',
1870                 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1871                 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1872                 'upload_date': '20151107',
1873             },
1874             'params': {
1875                 'skip_download': True,
1876             },
1877             'skip': 'This video does not exist.',
1878         },
1879         {
1880             # Video with incomplete 'yt:stretch=16:'
1881             'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1882             'only_matching': True,
1883         },
1884         {
1885             # Video licensed under Creative Commons
1886             'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1887             'info_dict': {
1888                 'id': 'M4gD1WSo5mA',
1889                 'ext': 'mp4',
1890                 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1891                 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1892                 'duration': 721,
1893                 'upload_date': '20150128',
1894                 'license': 'Creative Commons Attribution license (reuse allowed)',
1895                 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1896                 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1897                 'like_count': int,
1898                 'age_limit': 0,
1899                 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1900                 'channel': 'The Berkman Klein Center for Internet & Society',
1901                 'availability': 'public',
1902                 'view_count': int,
1903                 'categories': ['Education'],
1904                 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1905                 'live_status': 'not_live',
1906                 'playable_in_embed': True,
1907                 'channel_follower_count': int,
1908                 'chapters': list,
1909                 'uploader': 'The Berkman Klein Center for Internet & Society',
1910                 'uploader_id': '@BKCHarvard',
1911                 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1912                 'timestamp': 1422422076,
1913             },
1914             'params': {
1915                 'skip_download': True,
1916             },
1917         },
1918         {
1919             'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1920             'info_dict': {
1921                 'id': 'eQcmzGIKrzg',
1922                 'ext': 'mp4',
1923                 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1924                 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1925                 'duration': 4060,
1926                 'upload_date': '20151120',
1927                 'license': 'Creative Commons Attribution license (reuse allowed)',
1928                 'playable_in_embed': True,
1929                 'tags': 'count:12',
1930                 'like_count': int,
1931                 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1932                 'age_limit': 0,
1933                 'availability': 'public',
1934                 'categories': ['News & Politics'],
1935                 'channel': 'Bernie Sanders',
1936                 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1937                 'view_count': int,
1938                 'live_status': 'not_live',
1939                 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1940                 'comment_count': int,
1941                 'channel_follower_count': int,
1942                 'chapters': list,
1943                 'uploader': 'Bernie Sanders',
1944                 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1945                 'uploader_id': '@BernieSanders',
1946                 'channel_is_verified': True,
1947                 'heatmap': 'count:100',
1948                 'timestamp': 1447987198,
1949             },
1950             'params': {
1951                 'skip_download': True,
1952             },
1953         },
1954         {
1955             'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;amp;v=V36LpHqtcDY',
1956             'only_matching': True,
1957         },
1958         {
1959             # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1960             'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1961             'only_matching': True,
1962         },
1963         {
1964             # Rental video preview
1965             'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1966             'info_dict': {
1967                 'id': 'uGpuVWrhIzE',
1968                 'ext': 'mp4',
1969                 'title': 'Piku - Trailer',
1970                 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1971                 'upload_date': '20150811',
1972                 'license': 'Standard YouTube License',
1973             },
1974             'params': {
1975                 'skip_download': True,
1976             },
1977             'skip': 'This video is not available.',
1978         },
1979         {
1980             # YouTube Red video with episode data
1981             'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1982             'info_dict': {
1983                 'id': 'iqKdEhx-dD4',
1984                 'ext': 'mp4',
1985                 'title': 'Isolation - Mind Field (Ep 1)',
1986                 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1987                 'duration': 2085,
1988                 'upload_date': '20170118',
1989                 'series': 'Mind Field',
1990                 'season_number': 1,
1991                 'episode_number': 1,
1992                 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1993                 'tags': 'count:12',
1994                 'view_count': int,
1995                 'availability': 'public',
1996                 'age_limit': 0,
1997                 'channel': 'Vsauce',
1998                 'episode': 'Episode 1',
1999                 'categories': ['Entertainment'],
2000                 'season': 'Season 1',
2001                 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
2002                 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
2003                 'like_count': int,
2004                 'playable_in_embed': True,
2005                 'live_status': 'not_live',
2006                 'channel_follower_count': int,
2007                 'uploader': 'Vsauce',
2008                 'uploader_url': 'https://www.youtube.com/@Vsauce',
2009                 'uploader_id': '@Vsauce',
2010                 'comment_count': int,
2011                 'channel_is_verified': True,
2012                 'timestamp': 1484761047,
2013             },
2014             'params': {
2015                 'skip_download': True,
2016             },
2017             'expected_warnings': [
2018                 'Skipping DASH manifest',
2019             ],
2020         },
2021         {
2022             # The following content has been identified by the YouTube community
2023             # as inappropriate or offensive to some audiences.
2024             'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
2025             'info_dict': {
2026                 'id': '6SJNVb0GnPI',
2027                 'ext': 'mp4',
2028                 'title': 'Race Differences in Intelligence',
2029                 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2030                 'duration': 965,
2031                 'upload_date': '20140124',
2032             },
2033             'params': {
2034                 'skip_download': True,
2035             },
2036             'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2037         },
2038         {
2039             # itag 212
2040             'url': '1t24XAntNCY',
2041             'only_matching': True,
2042         },
2043         {
2044             # geo restricted to JP
2045             'url': 'sJL6WA-aGkQ',
2046             'only_matching': True,
2047         },
2048         {
2049             'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2050             'only_matching': True,
2051         },
2052         {
2053             'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2054             'only_matching': True,
2055         },
2056         {
2057             # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2058             'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2059             'only_matching': True,
2060         },
2061         {
2062             # DRM protected
2063             'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2064             'only_matching': True,
2065         },
2066         {
2067             # Video with unsupported adaptive stream type formats
2068             'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2069             'info_dict': {
2070                 'id': 'Z4Vy8R84T1U',
2071                 'ext': 'mp4',
2072                 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2073                 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2074                 'duration': 433,
2075                 'upload_date': '20130923',
2076                 'formats': 'maxcount:10',
2077             },
2078             'params': {
2079                 'skip_download': True,
2080                 'youtube_include_dash_manifest': False,
2081             },
2082             'skip': 'not actual anymore',
2083         },
2084         {
2085             # Youtube Music Auto-generated description
2086             # TODO: fix metadata extraction
2087             'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2088             'info_dict': {
2089                 'id': 'MgNrAu2pzNs',
2090                 'ext': 'mp4',
2091                 'title': 'Voyeur Girl',
2092                 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2093                 'upload_date': '20190312',
2094                 'artists': ['Stephen'],
2095                 'creators': ['Stephen'],
2096                 'track': 'Voyeur Girl',
2097                 'album': 'it\'s too much love to know my dear',
2098                 'release_date': '20190313',
2099                 'alt_title': 'Voyeur Girl',
2100                 'view_count': int,
2101                 'playable_in_embed': True,
2102                 'like_count': int,
2103                 'categories': ['Music'],
2104                 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2105                 'channel': 'Stephen',  # TODO: should be "Stephen - Topic"
2106                 'uploader': 'Stephen',
2107                 'availability': 'public',
2108                 'duration': 169,
2109                 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2110                 'age_limit': 0,
2111                 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2112                 'tags': 'count:11',
2113                 'live_status': 'not_live',
2114                 'channel_follower_count': int,
2115             },
2116             'params': {
2117                 'skip_download': True,
2118             },
2119         },
2120         {
2121             'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2122             'only_matching': True,
2123         },
2124         {
2125             # invalid -> valid video id redirection
2126             'url': 'DJztXj2GPfl',
2127             'info_dict': {
2128                 'id': 'DJztXj2GPfk',
2129                 'ext': 'mp4',
2130                 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2131                 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2132                 'upload_date': '20090125',
2133                 'artist': 'Panjabi MC',
2134                 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2135                 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2136             },
2137             'params': {
2138                 'skip_download': True,
2139             },
2140             'skip': 'Video unavailable',
2141         },
2142         {
2143             # empty description results in an empty string
2144             'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2145             'info_dict': {
2146                 'id': 'x41yOUIvK2k',
2147                 'ext': 'mp4',
2148                 'title': 'IMG 3456',
2149                 'description': '',
2150                 'upload_date': '20170613',
2151                 'view_count': int,
2152                 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2153                 'like_count': int,
2154                 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2155                 'tags': [],
2156                 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2157                 'availability': 'public',
2158                 'age_limit': 0,
2159                 'categories': ['Pets & Animals'],
2160                 'duration': 7,
2161                 'playable_in_embed': True,
2162                 'live_status': 'not_live',
2163                 'channel': 'l\'Or Vert asbl',
2164                 'channel_follower_count': int,
2165                 'uploader': 'l\'Or Vert asbl',
2166                 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2167                 'uploader_id': '@ElevageOrVert',
2168                 'timestamp': 1497343210,
2169             },
2170             'params': {
2171                 'skip_download': True,
2172             },
2173         },
2174         {
2175             # with '};' inside yt initial data (see [1])
2176             # see [2] for an example with '};' inside ytInitialPlayerResponse
2177             # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2178             # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2179             'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2180             'info_dict': {
2181                 'id': 'CHqg6qOn4no',
2182                 'ext': 'mp4',
2183                 'title': 'Part 77   Sort a list of simple types in c#',
2184                 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2185                 'upload_date': '20130831',
2186                 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2187                 'like_count': int,
2188                 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2189                 'live_status': 'not_live',
2190                 'categories': ['Education'],
2191                 'availability': 'public',
2192                 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2193                 'tags': 'count:12',
2194                 'playable_in_embed': True,
2195                 'age_limit': 0,
2196                 'view_count': int,
2197                 'duration': 522,
2198                 'channel': 'kudvenkat',
2199                 'comment_count': int,
2200                 'channel_follower_count': int,
2201                 'chapters': list,
2202                 'uploader': 'kudvenkat',
2203                 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2204                 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2205                 'channel_is_verified': True,
2206                 'heatmap': 'count:100',
2207                 'timestamp': 1377976349,
2208             },
2209             'params': {
2210                 'skip_download': True,
2211             },
2212         },
2213         {
2214             # another example of '};' in ytInitialData
2215             'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2216             'only_matching': True,
2217         },
2218         {
2219             'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2220             'only_matching': True,
2221         },
2222         {
2223             # https://github.com/ytdl-org/youtube-dl/pull/28094
2224             'url': 'OtqTfy26tG0',
2225             'info_dict': {
2226                 'id': 'OtqTfy26tG0',
2227                 'ext': 'mp4',
2228                 'title': 'Burn Out',
2229                 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2230                 'upload_date': '20141120',
2231                 'artist': 'The Cinematic Orchestra',
2232                 'track': 'Burn Out',
2233                 'album': 'Every Day',
2234                 'like_count': int,
2235                 'live_status': 'not_live',
2236                 'alt_title': 'Burn Out',
2237                 'duration': 614,
2238                 'age_limit': 0,
2239                 'view_count': int,
2240                 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2241                 'creator': 'The Cinematic Orchestra',
2242                 'channel': 'The Cinematic Orchestra',
2243                 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2244                 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2245                 'availability': 'public',
2246                 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2247                 'categories': ['Music'],
2248                 'playable_in_embed': True,
2249                 'channel_follower_count': int,
2250                 'uploader': 'The Cinematic Orchestra',
2251                 'comment_count': int,
2252             },
2253             'params': {
2254                 'skip_download': True,
2255             },
2256         },
2257         {
2258             # controversial video, only works with bpctr when authenticated with cookies
2259             'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2260             'only_matching': True,
2261         },
2262         {
2263             # controversial video, requires bpctr/contentCheckOk
2264             'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2265             'info_dict': {
2266                 'id': 'SZJvDhaSDnc',
2267                 'ext': 'mp4',
2268                 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2269                 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2270                 'upload_date': '20140716',
2271                 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2272                 'duration': 170,
2273                 'categories': ['News & Politics'],
2274                 'view_count': int,
2275                 'channel': 'CBS Mornings',
2276                 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2277                 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2278                 'age_limit': 18,
2279                 'availability': 'needs_auth',
2280                 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2281                 'like_count': int,
2282                 'live_status': 'not_live',
2283                 'playable_in_embed': True,
2284                 'channel_follower_count': int,
2285                 'uploader': 'CBS Mornings',
2286                 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2287                 'uploader_id': '@CBSMornings',
2288                 'comment_count': int,
2289                 'channel_is_verified': True,
2290                 'timestamp': 1405513526,
2291             },
2292         },
2293         {
2294             # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2295             'url': 'cBvYw8_A0vQ',
2296             'info_dict': {
2297                 'id': 'cBvYw8_A0vQ',
2298                 'ext': 'mp4',
2299                 'title': '4K Ueno Okachimachi  Street  Scenes  上野御徒町歩き',
2300                 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2301                 'upload_date': '20201120',
2302                 'duration': 1456,
2303                 'categories': ['Travel & Events'],
2304                 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2305                 'view_count': int,
2306                 'channel': 'Walk around Japan',
2307                 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2308                 'thumbnail': 'https://i.ytimg.com/vi/cBvYw8_A0vQ/hqdefault.jpg',
2309                 'age_limit': 0,
2310                 'availability': 'public',
2311                 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2312                 'live_status': 'not_live',
2313                 'playable_in_embed': True,
2314                 'channel_follower_count': int,
2315                 'uploader': 'Walk around Japan',
2316                 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2317                 'uploader_id': '@walkaroundjapan7124',
2318                 'timestamp': 1605884416,
2319             },
2320             'params': {
2321                 'skip_download': True,
2322             },
2323         }, {
2324             # Has multiple audio streams
2325             'url': 'WaOKSUlf4TM',
2326             'only_matching': True,
2327         }, {
2328             # Requires Premium: has format 141 when requested using YTM url
2329             'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2330             'only_matching': True,
2331         }, {
2332             # multiple subtitles with same lang_code
2333             'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2334             'only_matching': True,
2335         }, {
2336             # Force use android client fallback
2337             'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2338             'info_dict': {
2339                 'id': 'YOelRv7fMxY',
2340                 'title': 'DIGGING A SECRET TUNNEL Part 1',
2341                 'ext': '3gp',
2342                 'upload_date': '20210624',
2343                 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2344                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2345                 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2346                 'duration': 596,
2347                 'categories': ['Entertainment'],
2348                 'view_count': int,
2349                 'channel': 'colinfurze',
2350                 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2351                 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2352                 'age_limit': 0,
2353                 'availability': 'public',
2354                 'like_count': int,
2355                 'live_status': 'not_live',
2356                 'playable_in_embed': True,
2357                 'channel_follower_count': int,
2358                 'chapters': list,
2359                 'uploader': 'colinfurze',
2360                 'uploader_url': 'https://www.youtube.com/@colinfurze',
2361                 'uploader_id': '@colinfurze',
2362                 'comment_count': int,
2363                 'channel_is_verified': True,
2364                 'heatmap': 'count:100',
2365             },
2366             'params': {
2367                 'format': '17',  # 3gp format available on android
2368                 'extractor_args': {'youtube': {'player_client': ['android']}},
2369             },
2370             'skip': 'android client broken',
2371         },
2372         {
2373             # Skip download of additional client configs (remix client config in this case)
2374             'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2375             'only_matching': True,
2376             'params': {
2377                 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2378             },
2379         }, {
2380             # shorts
2381             'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2382             'only_matching': True,
2383         }, {
2384             'note': 'Storyboards',
2385             'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2386             'info_dict': {
2387                 'id': '5KLPxDtMqe8',
2388                 'ext': 'mhtml',
2389                 'format_id': 'sb0',
2390                 'title': 'Your Brain is Plastic',
2391                 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2392                 'upload_date': '20140324',
2393                 'like_count': int,
2394                 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2395                 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2396                 'view_count': int,
2397                 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2398                 'playable_in_embed': True,
2399                 'tags': 'count:12',
2400                 'availability': 'public',
2401                 'channel': 'SciShow',
2402                 'live_status': 'not_live',
2403                 'duration': 248,
2404                 'categories': ['Education'],
2405                 'age_limit': 0,
2406                 'channel_follower_count': int,
2407                 'chapters': list,
2408                 'uploader': 'SciShow',
2409                 'uploader_url': 'https://www.youtube.com/@SciShow',
2410                 'uploader_id': '@SciShow',
2411                 'comment_count': int,
2412                 'channel_is_verified': True,
2413                 'heatmap': 'count:100',
2414                 'timestamp': 1395685455,
2415             }, 'params': {'format': 'mhtml', 'skip_download': True},
2416         }, {
2417             # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2418             'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2419             'info_dict': {
2420                 'id': '2NUZ8W2llS4',
2421                 'ext': 'mp4',
2422                 'title': 'The NP that test your phone performance 🙂',
2423                 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2424                 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2425                 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2426                 'duration': 21,
2427                 'view_count': int,
2428                 'age_limit': 0,
2429                 'categories': ['Gaming'],
2430                 'tags': 'count:23',
2431                 'playable_in_embed': True,
2432                 'live_status': 'not_live',
2433                 'upload_date': '20220103',
2434                 'like_count': int,
2435                 'availability': 'public',
2436                 'channel': 'Leon Nguyen',
2437                 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2438                 'comment_count': int,
2439                 'channel_follower_count': int,
2440                 'uploader': 'Leon Nguyen',
2441                 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2442                 'uploader_id': '@LeonNguyen',
2443                 'heatmap': 'count:100',
2444                 'timestamp': 1641170939,
2445             },
2446         }, {
2447             # date text is premiered video, ensure upload date in UTC (published 1641172509)
2448             'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2449             'info_dict': {
2450                 'id': 'mzZzzBU6lrM',
2451                 'ext': 'mp4',
2452                 'title': 'I Met GeorgeNotFound In Real Life...',
2453                 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2454                 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2455                 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2456                 'duration': 955,
2457                 'view_count': int,
2458                 'age_limit': 0,
2459                 'categories': ['Entertainment'],
2460                 'tags': 'count:26',
2461                 'playable_in_embed': True,
2462                 'live_status': 'not_live',
2463                 'release_timestamp': 1641172509,
2464                 'release_date': '20220103',
2465                 'upload_date': '20220103',
2466                 'like_count': int,
2467                 'availability': 'public',
2468                 'channel': 'Quackity',
2469                 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2470                 'channel_follower_count': int,
2471                 'uploader': 'Quackity',
2472                 'uploader_id': '@Quackity',
2473                 'uploader_url': 'https://www.youtube.com/@Quackity',
2474                 'comment_count': int,
2475                 'channel_is_verified': True,
2476                 'heatmap': 'count:100',
2477                 'timestamp': 1641172509,
2478             },
2479         },
2480         {   # continuous livestream.
2481             # Upload date was 2022-07-12T05:12:29-07:00, while stream start is 2022-07-12T15:59:30+00:00
2482             'url': 'https://www.youtube.com/watch?v=jfKfPfyJRdk',
2483             'info_dict': {
2484                 'id': 'jfKfPfyJRdk',
2485                 'ext': 'mp4',
2486                 'channel_id': 'UCSJ4gkVC6NrvII8umztf0Ow',
2487                 'like_count': int,
2488                 'uploader': 'Lofi Girl',
2489                 'categories': ['Music'],
2490                 'concurrent_view_count': int,
2491                 'playable_in_embed': True,
2492                 'timestamp': 1657627949,
2493                 'release_date': '20220712',
2494                 'channel_url': 'https://www.youtube.com/channel/UCSJ4gkVC6NrvII8umztf0Ow',
2495                 'description': 'md5:13a6f76df898f5674f9127139f3df6f7',
2496                 'age_limit': 0,
2497                 'thumbnail': 'https://i.ytimg.com/vi/jfKfPfyJRdk/maxresdefault.jpg',
2498                 'release_timestamp': 1657641570,
2499                 'uploader_url': 'https://www.youtube.com/@LofiGirl',
2500                 'channel_follower_count': int,
2501                 'channel_is_verified': True,
2502                 'title': r're:^lofi hip hop radio 📚 - beats to relax/study to',
2503                 'view_count': int,
2504                 'live_status': 'is_live',
2505                 'tags': 'count:32',
2506                 'channel': 'Lofi Girl',
2507                 'availability': 'public',
2508                 'upload_date': '20220712',
2509                 'uploader_id': '@LofiGirl',
2510             },
2511             'params': {'skip_download': True},
2512         }, {
2513             'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2514             'info_dict': {
2515                 'id': 'tjjjtzRLHvA',
2516                 'ext': 'mp4',
2517                 'title': 'ハッシュタグ無し };if window.ytcsi',
2518                 'upload_date': '20220323',
2519                 'like_count': int,
2520                 'availability': 'unlisted',
2521                 'channel': 'Lesmiscore',
2522                 'thumbnail': r're:^https?://.*\.jpg',
2523                 'age_limit': 0,
2524                 'categories': ['Music'],
2525                 'view_count': int,
2526                 'description': '',
2527                 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2528                 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2529                 'live_status': 'not_live',
2530                 'playable_in_embed': True,
2531                 'channel_follower_count': int,
2532                 'duration': 6,
2533                 'tags': [],
2534                 'uploader_id': '@lesmiscore',
2535                 'uploader': 'Lesmiscore',
2536                 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2537                 'timestamp': 1648005313,
2538             },
2539         }, {
2540             # Prefer primary title+description language metadata by default
2541             # Do not prefer translated description if primary is empty
2542             'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2543             'info_dict': {
2544                 'id': 'el3E4MbxRqQ',
2545                 'ext': 'mp4',
2546                 'title': 'dlp test video 2 - primary sv no desc',
2547                 'description': '',
2548                 'channel': 'cole-dlp-test-acc',
2549                 'tags': [],
2550                 'view_count': int,
2551                 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2552                 'like_count': int,
2553                 'playable_in_embed': True,
2554                 'availability': 'unlisted',
2555                 'thumbnail': r're:^https?://.*\.jpg',
2556                 'age_limit': 0,
2557                 'duration': 5,
2558                 'live_status': 'not_live',
2559                 'upload_date': '20220908',
2560                 'categories': ['People & Blogs'],
2561                 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2562                 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2563                 'uploader_id': '@coletdjnz',
2564                 'uploader': 'cole-dlp-test-acc',
2565                 'timestamp': 1662677394,
2566             },
2567             'params': {'skip_download': True},
2568         }, {
2569             # Extractor argument: prefer translated title+description
2570             'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2571             'info_dict': {
2572                 'id': 'gHKT4uU8Zng',
2573                 'ext': 'mp4',
2574                 'channel': 'cole-dlp-test-acc',
2575                 'tags': [],
2576                 'duration': 5,
2577                 'live_status': 'not_live',
2578                 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2579                 'upload_date': '20220729',
2580                 'view_count': int,
2581                 'categories': ['People & Blogs'],
2582                 'thumbnail': r're:^https?://.*\.jpg',
2583                 'title': 'dlp test video title translated (fr)',
2584                 'availability': 'public',
2585                 'age_limit': 0,
2586                 'description': 'dlp test video description translated (fr)',
2587                 'playable_in_embed': True,
2588                 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2589                 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2590                 'uploader_id': '@coletdjnz',
2591                 'uploader': 'cole-dlp-test-acc',
2592                 'timestamp': 1659073275,
2593                 'like_count': int,
2594             },
2595             'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2596             'expected_warnings': [r'Preferring "fr" translated fields'],
2597         }, {
2598             'note': '6 channel audio',
2599             'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2600             'only_matching': True,
2601         }, {
2602             'note': 'Multiple HLS formats with same itag',
2603             'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2604             'info_dict': {
2605                 'id': 'kX3nB4PpJko',
2606                 'ext': 'mp4',
2607                 'categories': ['Entertainment'],
2608                 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2609                 'live_status': 'not_live',
2610                 'duration': 937,
2611                 'channel_follower_count': int,
2612                 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2613                 'title': 'Last To Take Hand Off Jet, Keeps It!',
2614                 'channel': 'MrBeast',
2615                 'playable_in_embed': True,
2616                 'view_count': int,
2617                 'upload_date': '20221112',
2618                 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2619                 'age_limit': 0,
2620                 'availability': 'public',
2621                 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2622                 'like_count': int,
2623                 'tags': [],
2624                 'uploader': 'MrBeast',
2625                 'uploader_url': 'https://www.youtube.com/@MrBeast',
2626                 'uploader_id': '@MrBeast',
2627                 'comment_count': int,
2628                 'channel_is_verified': True,
2629                 'heatmap': 'count:100',
2630             },
2631             'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2632         }, {
2633             'note': 'Audio formats with Dynamic Range Compression',
2634             'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2635             'info_dict': {
2636                 'id': 'Tq92D6wQ1mg',
2637                 'ext': 'webm',
2638                 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2639                 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2640                 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2641                 'channel_follower_count': int,
2642                 'description': 'md5:17eccca93a786d51bc67646756894066',
2643                 'upload_date': '20191228',
2644                 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2645                 'playable_in_embed': True,
2646                 'like_count': int,
2647                 'categories': ['Entertainment'],
2648                 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2649                 'age_limit': 18,
2650                 'channel': 'Projekt Melody',
2651                 'view_count': int,
2652                 'availability': 'needs_auth',
2653                 'comment_count': int,
2654                 'live_status': 'not_live',
2655                 'duration': 106,
2656                 'uploader': 'Projekt Melody',
2657                 'uploader_id': '@ProjektMelody',
2658                 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2659                 'timestamp': 1577508724,
2660             },
2661             'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2662         },
2663         {
2664             'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2665             'info_dict': {
2666                 'id': 'qVv6vCqciTM',
2667                 'ext': 'mp4',
2668                 'age_limit': 0,
2669                 'comment_count': int,
2670                 'chapters': 'count:13',
2671                 'upload_date': '20221223',
2672                 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2673                 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2674                 'like_count': int,
2675                 'release_date': '20221223',
2676                 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2677                 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2678                 'view_count': int,
2679                 'playable_in_embed': True,
2680                 'duration': 4438,
2681                 'availability': 'public',
2682                 'channel_follower_count': int,
2683                 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2684                 'categories': ['Entertainment'],
2685                 'live_status': 'was_live',
2686                 'release_timestamp': 1671793345,
2687                 'channel': 'さなちゃんねる',
2688                 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2689                 'uploader': 'さなちゃんねる',
2690                 'uploader_url': 'https://www.youtube.com/@sana_natori',
2691                 'uploader_id': '@sana_natori',
2692                 'channel_is_verified': True,
2693                 'heatmap': 'count:100',
2694                 'timestamp': 1671798112,
2695             },
2696         },
2697         {
2698             # Fallbacks when webpage and web client is unavailable
2699             'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2700             'info_dict': {
2701                 'id': 'wSSmNUl9Snw',
2702                 'ext': 'mp4',
2703                 # 'categories': ['Science & Technology'],
2704                 'view_count': int,
2705                 'chapters': 'count:2',
2706                 'channel': 'Scott Manley',
2707                 'like_count': int,
2708                 'age_limit': 0,
2709                 # 'availability': 'public',
2710                 'channel_follower_count': int,
2711                 'live_status': 'not_live',
2712                 'upload_date': '20170831',
2713                 'duration': 682,
2714                 'tags': 'count:8',
2715                 'uploader_url': 'https://www.youtube.com/@scottmanley',
2716                 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2717                 'uploader': 'Scott Manley',
2718                 'uploader_id': '@scottmanley',
2719                 'title': 'The Computer Hack That Saved Apollo 14',
2720                 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2721                 'thumbnail': r're:^https?://.*\.webp',
2722                 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2723                 'playable_in_embed': True,
2724                 'comment_count': int,
2725                 'channel_is_verified': True,
2726                 'heatmap': 'count:100',
2727             },
2728             'params': {
2729                 'extractor_args': {'youtube': {'player_client': ['ios'], 'player_skip': ['webpage']}},
2730             },
2731         },
2732     ]
2733
2734     _WEBPAGE_TESTS = [
2735         # YouTube <object> embed
2736         {
2737             'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2738             'md5': '873c81d308b979f0e23ee7e620b312a3',
2739             'info_dict': {
2740                 'id': 'msN87y-iEx0',
2741                 'ext': 'mp4',
2742                 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2743                 'upload_date': '20080526',
2744                 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2745                 'age_limit': 0,
2746                 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2747                 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2748                 'playable_in_embed': True,
2749                 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2750                 'like_count': int,
2751                 'comment_count': int,
2752                 'channel': 'Christopher Sykes',
2753                 'live_status': 'not_live',
2754                 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2755                 'availability': 'public',
2756                 'duration': 195,
2757                 'view_count': int,
2758                 'categories': ['Science & Technology'],
2759                 'channel_follower_count': int,
2760                 'uploader': 'Christopher Sykes',
2761                 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2762                 'uploader_id': '@ChristopherSykesDocumentaries',
2763                 'heatmap': 'count:100',
2764                 'timestamp': 1211825920,
2765             },
2766             'params': {
2767                 'skip_download': True,
2768             },
2769         },
2770     ]
2771
2772     @classmethod
2773     def suitable(cls, url):
2774         from ..utils import parse_qs
2775
2776         qs = parse_qs(url)
2777         if qs.get('list', [None])[0]:
2778             return False
2779         return super().suitable(url)
2780
2781     def __init__(self, *args, **kwargs):
2782         super().__init__(*args, **kwargs)
2783         self._code_cache = {}
2784         self._player_cache = {}
2785
2786     def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2787         lock = threading.Lock()
2788         start_time = time.time()
2789         formats = [f for f in formats if f.get('is_from_start')]
2790
2791         def refetch_manifest(format_id, delay):
2792             nonlocal formats, start_time, is_live
2793             if time.time() <= start_time + delay:
2794                 return
2795
2796             _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2797             video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2798             microformats = traverse_obj(
2799                 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2800                 expected_type=dict)
2801             _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2802             is_live = live_status == 'is_live'
2803             start_time = time.time()
2804
2805         def mpd_feed(format_id, delay):
2806             """
2807             @returns (manifest_url, manifest_stream_number, is_live) or None
2808             """
2809             for retry in self.RetryManager(fatal=False):
2810                 with lock:
2811                     refetch_manifest(format_id, delay)
2812
2813                 f = next((f for f in formats if f['format_id'] == format_id), None)
2814                 if not f:
2815                     if not is_live:
2816                         retry.error = f'{video_id}: Video is no longer live'
2817                     else:
2818                         retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2819                     continue
2820                 return f['manifest_url'], f['manifest_stream_number'], is_live
2821             return None
2822
2823         for f in formats:
2824             f['is_live'] = is_live
2825             gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2826                                     live_start_time, mpd_feed, not is_live and f.copy())
2827             if is_live:
2828                 f['fragments'] = gen
2829                 f['protocol'] = 'http_dash_segments_generator'
2830             else:
2831                 f['fragments'] = LazyList(gen({}))
2832                 del f['is_from_start']
2833
2834     def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2835         FETCH_SPAN, MAX_DURATION = 5, 432000
2836
2837         mpd_url, stream_number, is_live = None, None, True
2838
2839         begin_index = 0
2840         download_start_time = ctx.get('start') or time.time()
2841
2842         lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2843         if lack_early_segments:
2844             self.report_warning(bug_reports_message(
2845                 'Starting download from the last 120 hours of the live stream since '
2846                 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2847             lack_early_segments = True
2848
2849         known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2850         fragments, fragment_base_url = None, None
2851
2852         def _extract_sequence_from_mpd(refresh_sequence, immediate):
2853             nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2854             # Obtain from MPD's maximum seq value
2855             old_mpd_url = mpd_url
2856             last_error = ctx.pop('last_error', None)
2857             expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2858             mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2859                                                or (mpd_url, stream_number, False))
2860             if not refresh_sequence:
2861                 if expire_fast and not is_live:
2862                     return False, last_seq
2863                 elif old_mpd_url == mpd_url:
2864                     return True, last_seq
2865             if manifestless_orig_fmt:
2866                 fmt_info = manifestless_orig_fmt
2867             else:
2868                 try:
2869                     fmts, _ = self._extract_mpd_formats_and_subtitles(
2870                         mpd_url, None, note=False, errnote=False, fatal=False)
2871                 except ExtractorError:
2872                     fmts = None
2873                 if not fmts:
2874                     no_fragment_score += 2
2875                     return False, last_seq
2876                 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2877             fragments = fmt_info['fragments']
2878             fragment_base_url = fmt_info['fragment_base_url']
2879             assert fragment_base_url
2880
2881             _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2882             return True, _last_seq
2883
2884         self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2885         while is_live:
2886             fetch_time = time.time()
2887             if no_fragment_score > 30:
2888                 return
2889             if last_segment_url:
2890                 # Obtain from "X-Head-Seqnum" header value from each segment
2891                 try:
2892                     urlh = self._request_webpage(
2893                         last_segment_url, None, note=False, errnote=False, fatal=False)
2894                 except ExtractorError:
2895                     urlh = None
2896                 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2897                 if last_seq is None:
2898                     no_fragment_score += 2
2899                     last_segment_url = None
2900                     continue
2901             else:
2902                 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2903                 no_fragment_score += 2
2904                 if not should_continue:
2905                     continue
2906
2907             if known_idx > last_seq:
2908                 last_segment_url = None
2909                 continue
2910
2911             last_seq += 1
2912
2913             if begin_index < 0 and known_idx < 0:
2914                 # skip from the start when it's negative value
2915                 known_idx = last_seq + begin_index
2916             if lack_early_segments:
2917                 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2918             try:
2919                 for idx in range(known_idx, last_seq):
2920                     # do not update sequence here or you'll get skipped some part of it
2921                     should_continue, _ = _extract_sequence_from_mpd(False, False)
2922                     if not should_continue:
2923                         known_idx = idx - 1
2924                         raise ExtractorError('breaking out of outer loop')
2925                     last_segment_url = urljoin(fragment_base_url, f'sq/{idx}')
2926                     yield {
2927                         'url': last_segment_url,
2928                         'fragment_count': last_seq,
2929                     }
2930                 if known_idx == last_seq:
2931                     no_fragment_score += 5
2932                 else:
2933                     no_fragment_score = 0
2934                 known_idx = last_seq
2935             except ExtractorError:
2936                 continue
2937
2938             if manifestless_orig_fmt:
2939                 # Stop at the first iteration if running for post-live manifestless;
2940                 # fragment count no longer increase since it starts
2941                 break
2942
2943             time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2944
2945     def _extract_player_url(self, *ytcfgs, webpage=None):
2946         player_url = traverse_obj(
2947             ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2948             get_all=False, expected_type=str)
2949         if not player_url:
2950             return
2951         return urljoin('https://www.youtube.com', player_url)
2952
2953     def _download_player_url(self, video_id, fatal=False):
2954         res = self._download_webpage(
2955             'https://www.youtube.com/iframe_api',
2956             note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2957         if res:
2958             player_version = self._search_regex(
2959                 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2960             if player_version:
2961                 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2962
2963     def _signature_cache_id(self, example_sig):
2964         """ Return a string representation of a signature """
2965         return '.'.join(str(len(part)) for part in example_sig.split('.'))
2966
2967     @classmethod
2968     def _extract_player_info(cls, player_url):
2969         for player_re in cls._PLAYER_INFO_RE:
2970             id_m = re.search(player_re, player_url)
2971             if id_m:
2972                 break
2973         else:
2974             raise ExtractorError(f'Cannot identify player {player_url!r}')
2975         return id_m.group('id')
2976
2977     def _load_player(self, video_id, player_url, fatal=True):
2978         player_id = self._extract_player_info(player_url)
2979         if player_id not in self._code_cache:
2980             code = self._download_webpage(
2981                 player_url, video_id, fatal=fatal,
2982                 note='Downloading player ' + player_id,
2983                 errnote=f'Download of {player_url} failed')
2984             if code:
2985                 self._code_cache[player_id] = code
2986         return self._code_cache.get(player_id)
2987
2988     def _extract_signature_function(self, video_id, player_url, example_sig):
2989         player_id = self._extract_player_info(player_url)
2990
2991         # Read from filesystem cache
2992         func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2993         assert os.path.basename(func_id) == func_id
2994
2995         self.write_debug(f'Extracting signature function {func_id}')
2996         cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2997
2998         if not cache_spec:
2999             code = self._load_player(video_id, player_url)
3000         if code:
3001             res = self._parse_sig_js(code)
3002             test_string = ''.join(map(chr, range(len(example_sig))))
3003             cache_spec = [ord(c) for c in res(test_string)]
3004             self.cache.store('youtube-sigfuncs', func_id, cache_spec)
3005
3006         return lambda s: ''.join(s[i] for i in cache_spec)
3007
3008     def _print_sig_code(self, func, example_sig):
3009         if not self.get_param('youtube_print_sig_code'):
3010             return
3011
3012         def gen_sig_code(idxs):
3013             def _genslice(start, end, step):
3014                 starts = '' if start == 0 else str(start)
3015                 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3016                 steps = '' if step == 1 else (':%d' % step)
3017                 return f's[{starts}{ends}{steps}]'
3018
3019             step = None
3020             # Quelch pyflakes warnings - start will be set when step is set
3021             start = '(Never used)'
3022             for i, prev in zip(idxs[1:], idxs[:-1]):
3023                 if step is not None:
3024                     if i - prev == step:
3025                         continue
3026                     yield _genslice(start, prev, step)
3027                     step = None
3028                     continue
3029                 if i - prev in [-1, 1]:
3030                     step = i - prev
3031                     start = prev
3032                     continue
3033                 else:
3034                     yield 's[%d]' % prev
3035             if step is None:
3036                 yield 's[%d]' % i
3037             else:
3038                 yield _genslice(start, i, step)
3039
3040         test_string = ''.join(map(chr, range(len(example_sig))))
3041         cache_res = func(test_string)
3042         cache_spec = [ord(c) for c in cache_res]
3043         expr_code = ' + '.join(gen_sig_code(cache_spec))
3044         signature_id_tuple = '({})'.format(', '.join(str(len(p)) for p in example_sig.split('.')))
3045         code = (f'if tuple(len(p) for p in s.split(\'.\')) == {signature_id_tuple}:\n'
3046                 f'    return {expr_code}\n')
3047         self.to_screen('Extracted signature function:\n' + code)
3048
3049     def _parse_sig_js(self, jscode):
3050         funcname = self._search_regex(
3051             (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3052              r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3053              r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3054              r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3055              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+\))?',
3056              r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3057              # Obsolete patterns
3058              r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3059              r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3060              r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3061              r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3062              r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3063              r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3064             jscode, 'Initial JS player signature function name', group='sig')
3065
3066         jsi = JSInterpreter(jscode)
3067         initial_function = jsi.extract_function(funcname)
3068         return lambda s: initial_function([s])
3069
3070     def _cached(self, func, *cache_id):
3071         def inner(*args, **kwargs):
3072             if cache_id not in self._player_cache:
3073                 try:
3074                     self._player_cache[cache_id] = func(*args, **kwargs)
3075                 except ExtractorError as e:
3076                     self._player_cache[cache_id] = e
3077                 except Exception as e:
3078                     self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3079
3080             ret = self._player_cache[cache_id]
3081             if isinstance(ret, Exception):
3082                 raise ret
3083             return ret
3084         return inner
3085
3086     def _decrypt_signature(self, s, video_id, player_url):
3087         """Turn the encrypted s field into a working signature"""
3088         extract_sig = self._cached(
3089             self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3090         func = extract_sig(video_id, player_url, s)
3091         self._print_sig_code(func, s)
3092         return func(s)
3093
3094     def _decrypt_nsig(self, s, video_id, player_url):
3095         """Turn the encrypted n field into a working signature"""
3096         if player_url is None:
3097             raise ExtractorError('Cannot decrypt nsig without player_url')
3098         player_url = urljoin('https://www.youtube.com', player_url)
3099
3100         try:
3101             jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3102         except ExtractorError as e:
3103             raise ExtractorError('Unable to extract nsig function code', cause=e)
3104         if self.get_param('youtube_print_sig_code'):
3105             self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3106
3107         try:
3108             extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3109             ret = extract_nsig(jsi, func_code)(s)
3110         except JSInterpreter.Exception as e:
3111             try:
3112                 jsi = PhantomJSwrapper(self, timeout=5000)
3113             except ExtractorError:
3114                 raise e
3115             self.report_warning(
3116                 f'Native nsig extraction failed: Trying with PhantomJS\n'
3117                 f'         n = {s} ; player = {player_url}', video_id)
3118             self.write_debug(e, only_once=True)
3119
3120             args, func_body = func_code
3121             ret = jsi.execute(
3122                 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3123                 video_id=video_id, note='Executing signature code').strip()
3124
3125         self.write_debug(f'Decrypted nsig {s} => {ret}')
3126         return ret
3127
3128     def _extract_n_function_name(self, jscode):
3129         funcname, idx = self._search_regex(
3130             r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3131             jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3132         if not idx:
3133             return funcname
3134
3135         return json.loads(js_to_json(self._search_regex(
3136             rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3137             f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3138
3139     def _extract_n_function_code(self, video_id, player_url):
3140         player_id = self._extract_player_info(player_url)
3141         func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3142         jscode = func_code or self._load_player(video_id, player_url)
3143         jsi = JSInterpreter(jscode)
3144
3145         if func_code:
3146             return jsi, player_id, func_code
3147
3148         func_name = self._extract_n_function_name(jscode)
3149
3150         # For redundancy
3151         func_code = self._search_regex(
3152             rf'''(?xs){func_name}\s*=\s*function\s*\((?P<var>[\w$]+)\)\s*
3153                      # NB: The end of the regex is intentionally kept strict
3154                      {{(?P<code>.+?}}\s*return\ [\w$]+.join\(""\))}};''',
3155             jscode, 'nsig function', group=('var', 'code'), default=None)
3156         if func_code:
3157             func_code = ([func_code[0]], func_code[1])
3158         else:
3159             self.write_debug('Extracting nsig function with jsinterp')
3160             func_code = jsi.extract_function_code(func_name)
3161
3162         self.cache.store('youtube-nsig', player_id, func_code)
3163         return jsi, player_id, func_code
3164
3165     def _extract_n_function_from_code(self, jsi, func_code):
3166         func = jsi.extract_function_from_code(*func_code)
3167
3168         def extract_nsig(s):
3169             try:
3170                 ret = func([s])
3171             except JSInterpreter.Exception:
3172                 raise
3173             except Exception as e:
3174                 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3175
3176             if ret.startswith('enhanced_except_'):
3177                 raise JSInterpreter.Exception('Signature function returned an exception')
3178             return ret
3179
3180         return extract_nsig
3181
3182     def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3183         """
3184         Extract signatureTimestamp (sts)
3185         Required to tell API what sig/player version is in use.
3186         """
3187         sts = None
3188         if isinstance(ytcfg, dict):
3189             sts = int_or_none(ytcfg.get('STS'))
3190
3191         if not sts:
3192             # Attempt to extract from player
3193             if player_url is None:
3194                 error_msg = 'Cannot extract signature timestamp without player_url.'
3195                 if fatal:
3196                     raise ExtractorError(error_msg)
3197                 self.report_warning(error_msg)
3198                 return
3199             code = self._load_player(video_id, player_url, fatal=fatal)
3200             if code:
3201                 sts = int_or_none(self._search_regex(
3202                     r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3203                     'JS player signature timestamp', group='sts', fatal=fatal))
3204         return sts
3205
3206     def _mark_watched(self, video_id, player_responses):
3207         for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3208             label = 'fully ' if is_full else ''
3209             url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3210                             expected_type=url_or_none)
3211             if not url:
3212                 self.report_warning(f'Unable to mark {label}watched')
3213                 return
3214             parsed_url = urllib.parse.urlparse(url)
3215             qs = urllib.parse.parse_qs(parsed_url.query)
3216
3217             # cpn generation algorithm is reverse engineered from base.js.
3218             # In fact it works even with dummy cpn.
3219             CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3220             cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(16))
3221
3222             # # more consistent results setting it to right before the end
3223             video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3224
3225             qs.update({
3226                 'ver': ['2'],
3227                 'cpn': [cpn],
3228                 'cmt': video_length,
3229                 'el': 'detailpage',  # otherwise defaults to "shorts"
3230             })
3231
3232             if is_full:
3233                 # these seem to mark watchtime "history" in the real world
3234                 # they're required, so send in a single value
3235                 qs.update({
3236                     'st': 0,
3237                     'et': video_length,
3238                 })
3239
3240             url = urllib.parse.urlunparse(
3241                 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3242
3243             self._download_webpage(
3244                 url, video_id, f'Marking {label}watched',
3245                 'Unable to mark watched', fatal=False)
3246
3247     @classmethod
3248     def _extract_from_webpage(cls, url, webpage):
3249         # Invidious Instances
3250         # https://github.com/yt-dlp/yt-dlp/issues/195
3251         # https://github.com/iv-org/invidious/pull/1730
3252         mobj = re.search(
3253             r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3254             webpage)
3255         if mobj:
3256             yield cls.url_result(mobj.group('url'), cls)
3257             raise cls.StopExtraction
3258
3259         yield from super()._extract_from_webpage(url, webpage)
3260
3261         # lazyYT YouTube embed
3262         for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3263             yield cls.url_result(unescapeHTML(id_), cls, id_)
3264
3265         # Wordpress "YouTube Video Importer" plugin
3266         for m in re.findall(r'''(?x)<div[^>]+
3267                 class=(?P<q1>[\'"])[^\'"]*\byvii_single_video_player\b[^\'"]*(?P=q1)[^>]+
3268                 data-video_id=(?P<q2>[\'"])([^\'"]+)(?P=q2)''', webpage):
3269             yield cls.url_result(m[-1], cls, m[-1])
3270
3271     @classmethod
3272     def extract_id(cls, url):
3273         video_id = cls.get_temp_id(url)
3274         if not video_id:
3275             raise ExtractorError(f'Invalid URL: {url}')
3276         return video_id
3277
3278     def _extract_chapters_from_json(self, data, duration):
3279         chapter_list = traverse_obj(
3280             data, (
3281                 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3282                 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters',
3283             ), expected_type=list)
3284
3285         return self._extract_chapters_helper(
3286             chapter_list,
3287             start_function=lambda chapter: float_or_none(
3288                 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3289             title_function=lambda chapter: traverse_obj(
3290                 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3291             duration=duration)
3292
3293     def _extract_chapters_from_engagement_panel(self, data, duration):
3294         content_list = traverse_obj(
3295             data,
3296             ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3297             expected_type=list)
3298         chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3299         chapter_title = lambda chapter: self._get_text(chapter, 'title')
3300
3301         return next(filter(None, (
3302             self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3303                                           chapter_time, chapter_title, duration)
3304             for contents in content_list)), [])
3305
3306     def _extract_heatmap(self, data):
3307         return traverse_obj(data, (
3308             'frameworkUpdates', 'entityBatchUpdate', 'mutations',
3309             lambda _, v: v['payload']['macroMarkersListEntity']['markersList']['markerType'] == 'MARKER_TYPE_HEATMAP',
3310             'payload', 'macroMarkersListEntity', 'markersList', 'markers', ..., {
3311                 'start_time': ('startMillis', {functools.partial(float_or_none, scale=1000)}),
3312                 'end_time': {lambda x: (int(x['startMillis']) + int(x['durationMillis'])) / 1000},
3313                 'value': ('intensityScoreNormalized', {float_or_none}),
3314             })) or None
3315
3316     def _extract_comment(self, entities, parent=None):
3317         comment_entity_payload = get_first(entities, ('payload', 'commentEntityPayload', {dict}))
3318         if not (comment_id := traverse_obj(comment_entity_payload, ('properties', 'commentId', {str}))):
3319             return
3320
3321         toolbar_entity_payload = get_first(entities, ('payload', 'engagementToolbarStateEntityPayload', {dict}))
3322         time_text = traverse_obj(comment_entity_payload, ('properties', 'publishedTime', {str})) or ''
3323
3324         return {
3325             'id': comment_id,
3326             'parent': parent or 'root',
3327             **traverse_obj(comment_entity_payload, {
3328                 'text': ('properties', 'content', 'content', {str}),
3329                 'like_count': ('toolbar', 'likeCountA11y', {parse_count}),
3330                 'author_id': ('author', 'channelId', {self.ucid_or_none}),
3331                 'author': ('author', 'displayName', {str}),
3332                 'author_thumbnail': ('author', 'avatarThumbnailUrl', {url_or_none}),
3333                 'author_is_uploader': ('author', 'isCreator', {bool}),
3334                 'author_is_verified': ('author', 'isVerified', {bool}),
3335                 'author_url': ('author', 'channelCommand', 'innertubeCommand', (
3336                     ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'),
3337                 ), {lambda x: urljoin('https://www.youtube.com', x)}),
3338             }, get_all=False),
3339             'is_favorited': (None if toolbar_entity_payload is None else
3340                              toolbar_entity_payload.get('heartState') == 'TOOLBAR_HEART_STATE_HEARTED'),
3341             '_time_text': time_text,  # FIXME: non-standard, but we need a way of showing that it is an estimate.
3342             'timestamp': self._parse_time_text(time_text),
3343         }
3344
3345     def _extract_comment_old(self, comment_renderer, parent=None):
3346         comment_id = comment_renderer.get('commentId')
3347         if not comment_id:
3348             return
3349
3350         info = {
3351             'id': comment_id,
3352             'text': self._get_text(comment_renderer, 'contentText'),
3353             'like_count': self._get_count(comment_renderer, 'voteCount'),
3354             'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3355             'author': self._get_text(comment_renderer, 'authorText'),
3356             'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3357             'parent': parent or 'root',
3358         }
3359
3360         # Timestamp is an estimate calculated from the current time and time_text
3361         time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3362         timestamp = self._parse_time_text(time_text)
3363
3364         info.update({
3365             # FIXME: non-standard, but we need a way of showing that it is an estimate.
3366             '_time_text': time_text,
3367             'timestamp': timestamp,
3368         })
3369
3370         info['author_url'] = urljoin(
3371             'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3372                 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3373                 expected_type=str, get_all=False))
3374
3375         author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3376         if author_is_uploader is not None:
3377             info['author_is_uploader'] = author_is_uploader
3378
3379         comment_abr = traverse_obj(
3380             comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3381         if comment_abr is not None:
3382             info['is_favorited'] = 'creatorHeart' in comment_abr
3383
3384         badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3385         if self._has_badge(badges, BadgeType.VERIFIED):
3386             info['author_is_verified'] = True
3387
3388         is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3389         if is_pinned:
3390             info['is_pinned'] = True
3391
3392         return info
3393
3394     def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3395
3396         get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3397
3398         def extract_header(contents):
3399             _continuation = None
3400             for content in contents:
3401                 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3402                 expected_comment_count = self._get_count(
3403                     comments_header_renderer, 'countText', 'commentsCount')
3404
3405                 if expected_comment_count is not None:
3406                     tracker['est_total'] = expected_comment_count
3407                     self.to_screen(f'Downloading ~{expected_comment_count} comments')
3408                 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top')  # 1 = new, 0 = top
3409
3410                 sort_menu_item = try_get(
3411                     comments_header_renderer,
3412                     lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3413                 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3414
3415                 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3416                 if not _continuation:
3417                     continue
3418
3419                 sort_text = str_or_none(sort_menu_item.get('title'))
3420                 if not sort_text:
3421                     sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3422                 self.to_screen(f'Sorting comments by {sort_text.lower()}')
3423                 break
3424             return _continuation
3425
3426         def extract_thread(contents, entity_payloads):
3427             if not parent:
3428                 tracker['current_page_thread'] = 0
3429             for content in contents:
3430                 if not parent and tracker['total_parent_comments'] >= max_parents:
3431                     yield
3432                 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3433
3434                 # old comment format
3435                 if not entity_payloads:
3436                     comment_renderer = get_first(
3437                         (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3438                         expected_type=dict, default={})
3439
3440                     comment = self._extract_comment_old(comment_renderer, parent)
3441
3442                 # new comment format
3443                 else:
3444                     view_model = (
3445                         traverse_obj(comment_thread_renderer, ('commentViewModel', 'commentViewModel', {dict}))
3446                         or traverse_obj(content, ('commentViewModel', {dict})))
3447                     comment_keys = traverse_obj(view_model, (('commentKey', 'toolbarStateKey'), {str}))
3448                     if not comment_keys:
3449                         continue
3450                     entities = traverse_obj(entity_payloads, lambda _, v: v['entityKey'] in comment_keys)
3451                     comment = self._extract_comment(entities, parent)
3452                     if comment:
3453                         comment['is_pinned'] = traverse_obj(view_model, ('pinnedText', {str})) is not None
3454
3455                 if not comment:
3456                     continue
3457                 comment_id = comment['id']
3458
3459                 if comment.get('is_pinned'):
3460                     tracker['pinned_comment_ids'].add(comment_id)
3461                 # Sometimes YouTube may break and give us infinite looping comments.
3462                 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3463                 if comment_id in tracker['seen_comment_ids']:
3464                     if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3465                         # Pinned comments may appear a second time in newest first sort
3466                         # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3467                         continue
3468                     self.report_warning(
3469                         'Detected YouTube comments looping. Stopping comment extraction '
3470                         f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3471                     yield
3472                 else:
3473                     tracker['seen_comment_ids'].add(comment['id'])
3474
3475                 tracker['running_total'] += 1
3476                 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3477                 yield comment
3478
3479                 # Attempt to get the replies
3480                 comment_replies_renderer = try_get(
3481                     comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3482
3483                 if comment_replies_renderer:
3484                     tracker['current_page_thread'] += 1
3485                     comment_entries_iter = self._comment_entries(
3486                         comment_replies_renderer, ytcfg, video_id,
3487                         parent=comment.get('id'), tracker=tracker)
3488                     yield from itertools.islice(comment_entries_iter, min(
3489                         max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3490
3491         # Keeps track of counts across recursive calls
3492         if not tracker:
3493             tracker = {
3494                 'running_total': 0,
3495                 'est_total': None,
3496                 'current_page_thread': 0,
3497                 'total_parent_comments': 0,
3498                 'total_reply_comments': 0,
3499                 'seen_comment_ids': set(),
3500                 'pinned_comment_ids': set(),
3501             }
3502
3503         # TODO: Deprecated
3504         # YouTube comments have a max depth of 2
3505         max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3506         if max_depth:
3507             self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3508                                                 'Set max replies in the max-comments extractor argument instead')
3509         if max_depth == 1 and parent:
3510             return
3511
3512         max_comments, max_parents, max_replies, max_replies_per_thread, *_ = (
3513             int_or_none(p, default=sys.maxsize) for p in self._configuration_arg('max_comments') + [''] * 4)
3514
3515         continuation = self._extract_continuation(root_continuation_data)
3516
3517         response = None
3518         is_forced_continuation = False
3519         is_first_continuation = parent is None
3520         if is_first_continuation and not continuation:
3521             # Sometimes you can get comments by generating the continuation yourself,
3522             # even if YouTube initially reports them being disabled - e.g. stories comments.
3523             # Note: if the comment section is actually disabled, YouTube may return a response with
3524             # required check_get_keys missing. So we will disable that check initially in this case.
3525             continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3526             is_forced_continuation = True
3527
3528         continuation_items_path = (
3529             'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3530         for page_num in itertools.count(0):
3531             if not continuation:
3532                 break
3533             headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3534             comment_prog_str = f"({tracker['running_total']}/~{tracker['est_total']})"
3535             if page_num == 0:
3536                 if is_first_continuation:
3537                     note_prefix = 'Downloading comment section API JSON'
3538                 else:
3539                     note_prefix = '    Downloading comment API JSON reply thread %d %s' % (
3540                         tracker['current_page_thread'], comment_prog_str)
3541             else:
3542                 note_prefix = '{}Downloading comment{} API JSON page {} {}'.format(
3543                     '       ' if parent else '', ' replies' if parent else '',
3544                     page_num, comment_prog_str)
3545
3546             # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3547             # Ignore check if YouTube says the comment count is 0.
3548             check_get_keys = None
3549             if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3550                 check_get_keys = [[*continuation_items_path, ..., (
3551                     'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentViewModel', 'commentRenderer'))]]
3552             try:
3553                 response = self._extract_response(
3554                     item_id=None, query=continuation,
3555                     ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3556                     check_get_keys=check_get_keys)
3557             except ExtractorError as e:
3558                 # Ignore incomplete data error for replies if retries didn't work.
3559                 # This is to allow any other parent comments and comment threads to be downloaded.
3560                 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3561                 if 'incomplete data' in str(e).lower() and parent:
3562                     if self.get_param('ignoreerrors') in (True, 'only_download'):
3563                         self.report_warning(
3564                             'Received incomplete data for a comment reply thread and retrying did not help. '
3565                             'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3566                         return
3567                     else:
3568                         raise ExtractorError(
3569                             'Incomplete data received for comment reply thread. '
3570                             'Pass --ignore-errors to ignore and allow rest of comments to download.',
3571                             expected=True)
3572                 raise
3573             is_forced_continuation = False
3574             continuation = None
3575             mutations = traverse_obj(response, ('frameworkUpdates', 'entityBatchUpdate', 'mutations', ..., {dict}))
3576             for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3577                 if is_first_continuation:
3578                     continuation = extract_header(continuation_items)
3579                     is_first_continuation = False
3580                     if continuation:
3581                         break
3582                     continue
3583
3584                 for entry in extract_thread(continuation_items, mutations):
3585                     if not entry:
3586                         return
3587                     yield entry
3588                 continuation = self._extract_continuation({'contents': continuation_items})
3589                 if continuation:
3590                     break
3591
3592         message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3593         if message and not parent and tracker['running_total'] == 0:
3594             self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3595             raise self.CommentsDisabled
3596
3597     @staticmethod
3598     def _generate_comment_continuation(video_id):
3599         """
3600         Generates initial comment section continuation token from given video id
3601         """
3602         token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3603         return base64.b64encode(token.encode()).decode()
3604
3605     def _get_comments(self, ytcfg, video_id, contents, webpage):
3606         """Entry for comment extraction"""
3607         def _real_comment_extract(contents):
3608             renderer = next((
3609                 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3610                 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3611             yield from self._comment_entries(renderer, ytcfg, video_id)
3612
3613         max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3614         return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3615
3616     @staticmethod
3617     def _get_checkok_params():
3618         return {'contentCheckOk': True, 'racyCheckOk': True}
3619
3620     @classmethod
3621     def _generate_player_context(cls, sts=None):
3622         context = {
3623             'html5Preference': 'HTML5_PREF_WANTS',
3624         }
3625         if sts is not None:
3626             context['signatureTimestamp'] = sts
3627         return {
3628             'playbackContext': {
3629                 'contentPlaybackContext': context,
3630             },
3631             **cls._get_checkok_params(),
3632         }
3633
3634     @staticmethod
3635     def _is_agegated(player_response):
3636         if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3637             return True
3638
3639         reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3640         AGE_GATE_REASONS = (
3641             'confirm your age', 'age-restricted', 'inappropriate',  # reason
3642             'age_verification_required', 'age_check_required',  # status
3643         )
3644         return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3645
3646     @staticmethod
3647     def _is_unplayable(player_response):
3648         return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3649
3650     def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3651
3652         session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3653         syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3654         sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3655         headers = self.generate_api_headers(
3656             ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3657
3658         yt_query = {
3659             'videoId': video_id,
3660         }
3661
3662         pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3663         if pp_arg:
3664             yt_query['params'] = pp_arg
3665
3666         yt_query.update(self._generate_player_context(sts))
3667         return self._extract_response(
3668             item_id=video_id, ep='player', query=yt_query,
3669             ytcfg=player_ytcfg, headers=headers, fatal=True,
3670             default_client=client,
3671             note='Downloading {} player API JSON'.format(client.replace('_', ' ').strip()),
3672         ) or None
3673
3674     def _get_requested_clients(self, url, smuggled_data):
3675         requested_clients = []
3676         android_clients = []
3677         default = ['ios', 'web']
3678         allowed_clients = sorted(
3679             (client for client in INNERTUBE_CLIENTS if client[:1] != '_'),
3680             key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3681         for client in self._configuration_arg('player_client'):
3682             if client == 'default':
3683                 requested_clients.extend(default)
3684             elif client == 'all':
3685                 requested_clients.extend(allowed_clients)
3686             elif client not in allowed_clients:
3687                 self.report_warning(f'Skipping unsupported client {client}')
3688             elif client.startswith('android'):
3689                 android_clients.append(client)
3690             else:
3691                 requested_clients.append(client)
3692         # Force deprioritization of broken Android clients for format de-duplication
3693         requested_clients.extend(android_clients)
3694         if not requested_clients:
3695             requested_clients = default
3696
3697         if smuggled_data.get('is_music_url') or self.is_music_url(url):
3698             requested_clients.extend(
3699                 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3700
3701         return orderedSet(requested_clients)
3702
3703     def _invalid_player_response(self, pr, video_id):
3704         # YouTube may return a different video player response than expected.
3705         # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3706         if (pr_id := traverse_obj(pr, ('videoDetails', 'videoId'))) != video_id:
3707             return pr_id
3708
3709     def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3710         initial_pr = None
3711         if webpage:
3712             initial_pr = self._search_json(
3713                 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3714
3715         prs = []
3716         if initial_pr and not self._invalid_player_response(initial_pr, video_id):
3717             # Android player_response does not have microFormats which are needed for
3718             # extraction of some data. So we return the initial_pr with formats
3719             # stripped out even if not requested by the user
3720             # See: https://github.com/yt-dlp/yt-dlp/issues/501
3721             prs.append({**initial_pr, 'streamingData': None})
3722
3723         all_clients = set(clients)
3724         clients = clients[::-1]
3725
3726         def append_client(*client_names):
3727             """ Append the first client name that exists but not already used """
3728             for client_name in client_names:
3729                 actual_client = _split_innertube_client(client_name)[0]
3730                 if actual_client in INNERTUBE_CLIENTS:
3731                     if actual_client not in all_clients:
3732                         clients.append(client_name)
3733                         all_clients.add(actual_client)
3734                         return
3735
3736         tried_iframe_fallback = False
3737         player_url = None
3738         skipped_clients = {}
3739         while clients:
3740             client, base_client, variant = _split_innertube_client(clients.pop())
3741             player_ytcfg = master_ytcfg if client == 'web' else {}
3742             if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3743                 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3744
3745             player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3746             require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3747             if 'js' in self._configuration_arg('player_skip'):
3748                 require_js_player = False
3749                 player_url = None
3750
3751             if not player_url and not tried_iframe_fallback and require_js_player:
3752                 player_url = self._download_player_url(video_id)
3753                 tried_iframe_fallback = True
3754
3755             try:
3756                 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3757                     client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3758             except ExtractorError as e:
3759                 self.report_warning(e)
3760                 continue
3761
3762             if pr_id := self._invalid_player_response(pr, video_id):
3763                 skipped_clients[client] = pr_id
3764             elif pr:
3765                 # Save client name for introspection later
3766                 name = short_client_name(client)
3767                 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3768                 sd[STREAMING_DATA_CLIENT_NAME] = name
3769                 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3770                     f[STREAMING_DATA_CLIENT_NAME] = name
3771                 prs.append(pr)
3772
3773             # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3774             if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3775                 append_client(f'{base_client}_creator')
3776             elif self._is_agegated(pr):
3777                 if variant == 'tv_embedded':
3778                     append_client(f'{base_client}_embedded')
3779                 elif not variant:
3780                     append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3781
3782         if skipped_clients:
3783             self.report_warning(
3784                 f'Skipping player responses from {"/".join(skipped_clients)} clients '
3785                 f'(got player responses for video "{"/".join(set(skipped_clients.values()))}" instead of "{video_id}")')
3786             if not prs:
3787                 raise ExtractorError(
3788                     'All player responses are invalid. Your IP is likely being blocked by Youtube', expected=True)
3789         elif not prs:
3790             raise ExtractorError('Failed to extract any player response')
3791         return prs, player_url
3792
3793     def _needs_live_processing(self, live_status, duration):
3794         if (live_status == 'is_live' and self.get_param('live_from_start')
3795                 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3796             return live_status
3797
3798     def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3799         CHUNK_SIZE = 10 << 20
3800         PREFERRED_LANG_VALUE = 10
3801         original_language = None
3802         itags, stream_ids = collections.defaultdict(set), []
3803         itag_qualities, res_qualities = {}, {0: None}
3804         q = qualities([
3805             # Normally tiny is the smallest video-only formats. But
3806             # audio-only formats with unknown quality may get tagged as tiny
3807             'tiny',
3808             'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high',  # Audio only formats
3809             'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres',
3810         ])
3811         streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3812         format_types = self._configuration_arg('formats')
3813         all_formats = 'duplicate' in format_types
3814         if self._configuration_arg('include_duplicate_formats'):
3815             all_formats = True
3816             self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3817                                                 'Use formats=duplicate extractor argument instead')
3818
3819         def build_fragments(f):
3820             return LazyList({
3821                 'url': update_url_query(f['url'], {
3822                     'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}',
3823                 }),
3824             } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3825
3826         for fmt in streaming_formats:
3827             if fmt.get('targetDurationSec'):
3828                 continue
3829
3830             itag = str_or_none(fmt.get('itag'))
3831             audio_track = fmt.get('audioTrack') or {}
3832             stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3833             if not all_formats:
3834                 if stream_id in stream_ids:
3835                     continue
3836
3837             quality = fmt.get('quality')
3838             height = int_or_none(fmt.get('height'))
3839             if quality == 'tiny' or not quality:
3840                 quality = fmt.get('audioQuality', '').lower() or quality
3841             # The 3gp format (17) in android client has a quality of "small",
3842             # but is actually worse than other formats
3843             if itag == '17':
3844                 quality = 'tiny'
3845             if quality:
3846                 if itag:
3847                     itag_qualities[itag] = quality
3848                 if height:
3849                     res_qualities[height] = quality
3850             # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3851             # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3852             # number of fragment that would subsequently requested with (`&sq=N`)
3853             if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3854                 continue
3855
3856             fmt_url = fmt.get('url')
3857             if not fmt_url:
3858                 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3859                 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3860                 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3861                 if not all((sc, fmt_url, player_url, encrypted_sig)):
3862                     continue
3863                 try:
3864                     fmt_url += '&{}={}'.format(
3865                         traverse_obj(sc, ('sp', -1)) or 'signature',
3866                         self._decrypt_signature(encrypted_sig, video_id, player_url),
3867                     )
3868                 except ExtractorError as e:
3869                     self.report_warning('Signature extraction failed: Some formats may be missing',
3870                                         video_id=video_id, only_once=True)
3871                     self.write_debug(e, only_once=True)
3872                     continue
3873
3874             query = parse_qs(fmt_url)
3875             throttled = False
3876             if query.get('n'):
3877                 try:
3878                     decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3879                     fmt_url = update_url_query(fmt_url, {
3880                         'n': decrypt_nsig(query['n'][0], video_id, player_url),
3881                     })
3882                 except ExtractorError as e:
3883                     phantomjs_hint = ''
3884                     if isinstance(e, JSInterpreter.Exception):
3885                         phantomjs_hint = (f'         Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3886                                           f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3887                     if player_url:
3888                         self.report_warning(
3889                             f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3890                             f'         n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3891                         self.write_debug(e, only_once=True)
3892                     else:
3893                         self.report_warning(
3894                             'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3895                             video_id=video_id, only_once=True)
3896                     throttled = True
3897
3898             tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3899             is_default = audio_track.get('audioIsDefault')
3900             is_descriptive = 'descriptive' in (audio_track.get('displayName') or '').lower()
3901             language_code = audio_track.get('id', '').split('.')[0]
3902             if language_code and is_default:
3903                 original_language = language_code
3904
3905             format_duration = traverse_obj(fmt, ('approxDurationMs', {lambda x: float_or_none(x, 1000)}))
3906             # Some formats may have much smaller duration than others (possibly damaged during encoding)
3907             # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3908             # Make sure to avoid false positives with small duration differences.
3909             # E.g. __2ABJjxzNo, ySuUZEjARPY
3910             is_damaged = try_call(lambda: format_duration < duration // 2)
3911             if is_damaged:
3912                 self.report_warning(
3913                     f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3914
3915             client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3916             # Android client formats are broken due to integrity check enforcement
3917             # Ref: https://github.com/yt-dlp/yt-dlp/issues/9554
3918             is_broken = client_name and client_name.startswith(short_client_name('android'))
3919             if is_broken:
3920                 self.report_warning(
3921                     f'{video_id}: Android client formats are broken and may yield HTTP Error 403. '
3922                     'They will be deprioritized', only_once=True)
3923
3924             name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3925             fps = int_or_none(fmt.get('fps')) or 0
3926             dct = {
3927                 'asr': int_or_none(fmt.get('audioSampleRate')),
3928                 'filesize': int_or_none(fmt.get('contentLength')),
3929                 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3930                 'format_note': join_nonempty(
3931                     join_nonempty(audio_track.get('displayName'), is_default and ' (default)', delim=''),
3932                     name, fmt.get('isDrc') and 'DRC',
3933                     try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3934                     try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3935                     throttled and 'THROTTLED', is_damaged and 'DAMAGED', is_broken and 'BROKEN',
3936                     (self.get_param('verbose') or all_formats) and client_name,
3937                     delim=', '),
3938                 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3939                 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3940                                       + (100 if 'Premium' in name else 0)),
3941                 'fps': fps if fps > 1 else None,  # For some formats, fps is wrongly returned as 1
3942                 'audio_channels': fmt.get('audioChannels'),
3943                 'height': height,
3944                 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3945                 'has_drm': bool(fmt.get('drmFamilies')),
3946                 'tbr': tbr,
3947                 'filesize_approx': filesize_from_tbr(tbr, format_duration),
3948                 'url': fmt_url,
3949                 'width': int_or_none(fmt.get('width')),
3950                 'language': join_nonempty(language_code, 'desc' if is_descriptive else '') or None,
3951                 'language_preference': PREFERRED_LANG_VALUE if is_default else -10 if is_descriptive else -1,
3952                 # Strictly de-prioritize broken, damaged and 3gp formats
3953                 'preference': -20 if is_broken else -10 if is_damaged else -2 if itag == '17' else None,
3954             }
3955             mime_mobj = re.match(
3956                 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^"]+)")?', fmt.get('mimeType') or '')
3957             if mime_mobj:
3958                 dct['ext'] = mimetype2ext(mime_mobj.group(1))
3959                 dct.update(parse_codecs(mime_mobj.group(2)))
3960             if itag:
3961                 itags[itag].add(('https', dct.get('language')))
3962                 stream_ids.append(stream_id)
3963             single_stream = 'none' in (dct.get('acodec'), dct.get('vcodec'))
3964             if single_stream and dct.get('ext'):
3965                 dct['container'] = dct['ext'] + '_dash'
3966
3967             if (all_formats or 'dashy' in format_types) and dct['filesize']:
3968                 yield {
3969                     **dct,
3970                     'format_id': f'{dct["format_id"]}-dashy' if all_formats else dct['format_id'],
3971                     'protocol': 'http_dash_segments',
3972                     'fragments': build_fragments(dct),
3973                 }
3974             if all_formats or 'dashy' not in format_types:
3975                 dct['downloader_options'] = {'http_chunk_size': CHUNK_SIZE}
3976                 yield dct
3977
3978         needs_live_processing = self._needs_live_processing(live_status, duration)
3979         skip_bad_formats = 'incomplete' not in format_types
3980         if self._configuration_arg('include_incomplete_formats'):
3981             skip_bad_formats = False
3982             self._downloader.deprecated_feature('[youtube] include_incomplete_formats extractor argument is deprecated. '
3983                                                 'Use formats=incomplete extractor argument instead')
3984
3985         skip_manifests = set(self._configuration_arg('skip'))
3986         if (not self.get_param('youtube_include_hls_manifest', True)
3987                 or needs_live_processing == 'is_live'  # These will be filtered out by YoutubeDL anyway
3988                 or needs_live_processing and skip_bad_formats):
3989             skip_manifests.add('hls')
3990
3991         if not self.get_param('youtube_include_dash_manifest', True):
3992             skip_manifests.add('dash')
3993         if self._configuration_arg('include_live_dash'):
3994             self._downloader.deprecated_feature('[youtube] include_live_dash extractor argument is deprecated. '
3995                                                 'Use formats=incomplete extractor argument instead')
3996         elif skip_bad_formats and live_status == 'is_live' and needs_live_processing != 'is_live':
3997             skip_manifests.add('dash')
3998
3999         def process_manifest_format(f, proto, client_name, itag):
4000             key = (proto, f.get('language'))
4001             if not all_formats and key in itags[itag]:
4002                 return False
4003             itags[itag].add(key)
4004
4005             if itag and all_formats:
4006                 f['format_id'] = f'{itag}-{proto}'
4007             elif any(p != proto for p, _ in itags[itag]):
4008                 f['format_id'] = f'{itag}-{proto}'
4009             elif itag:
4010                 f['format_id'] = itag
4011
4012             if original_language and f.get('language') == original_language:
4013                 f['format_note'] = join_nonempty(f.get('format_note'), '(default)', delim=' ')
4014                 f['language_preference'] = PREFERRED_LANG_VALUE
4015
4016             if f.get('source_preference') is None:
4017                 f['source_preference'] = -1
4018
4019             if itag in ('616', '235'):
4020                 f['format_note'] = join_nonempty(f.get('format_note'), 'Premium', delim=' ')
4021                 f['source_preference'] += 100
4022
4023             f['quality'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id'].split('-')[0]), -1))
4024             if f['quality'] == -1 and f.get('height'):
4025                 f['quality'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height']))])
4026             if self.get_param('verbose') or all_formats:
4027                 f['format_note'] = join_nonempty(f.get('format_note'), client_name, delim=', ')
4028             if f.get('fps') and f['fps'] <= 1:
4029                 del f['fps']
4030
4031             if proto == 'hls' and f.get('has_drm'):
4032                 f['has_drm'] = 'maybe'
4033                 f['source_preference'] -= 5
4034             return True
4035
4036         subtitles = {}
4037         for sd in streaming_data:
4038             client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
4039
4040             hls_manifest_url = 'hls' not in skip_manifests and sd.get('hlsManifestUrl')
4041             if hls_manifest_url:
4042                 fmts, subs = self._extract_m3u8_formats_and_subtitles(
4043                     hls_manifest_url, video_id, 'mp4', fatal=False, live=live_status == 'is_live')
4044                 subtitles = self._merge_subtitles(subs, subtitles)
4045                 for f in fmts:
4046                     if process_manifest_format(f, 'hls', client_name, self._search_regex(
4047                             r'/itag/(\d+)', f['url'], 'itag', default=None)):
4048                         yield f
4049
4050             dash_manifest_url = 'dash' not in skip_manifests and sd.get('dashManifestUrl')
4051             if dash_manifest_url:
4052                 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
4053                 subtitles = self._merge_subtitles(subs, subtitles)  # Prioritize HLS subs over DASH
4054                 for f in formats:
4055                     if process_manifest_format(f, 'dash', client_name, f['format_id']):
4056                         f['filesize'] = int_or_none(self._search_regex(
4057                             r'/clen/(\d+)', f.get('fragment_base_url') or f['url'], 'file size', default=None))
4058                         if needs_live_processing:
4059                             f['is_from_start'] = True
4060
4061                         yield f
4062         yield subtitles
4063
4064     def _extract_storyboard(self, player_responses, duration):
4065         spec = get_first(
4066             player_responses, ('storyboards', 'playerStoryboardSpecRenderer', 'spec'), default='').split('|')[::-1]
4067         base_url = url_or_none(urljoin('https://i.ytimg.com/', spec.pop() or None))
4068         if not base_url:
4069             return
4070         L = len(spec) - 1
4071         for i, args in enumerate(spec):
4072             args = args.split('#')
4073             counts = list(map(int_or_none, args[:5]))
4074             if len(args) != 8 or not all(counts):
4075                 self.report_warning(f'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
4076                 continue
4077             width, height, frame_count, cols, rows = counts
4078             N, sigh = args[6:]
4079
4080             url = base_url.replace('$L', str(L - i)).replace('$N', N) + f'&sigh={sigh}'
4081             fragment_count = frame_count / (cols * rows)
4082             fragment_duration = duration / fragment_count
4083             yield {
4084                 'format_id': f'sb{i}',
4085                 'format_note': 'storyboard',
4086                 'ext': 'mhtml',
4087                 'protocol': 'mhtml',
4088                 'acodec': 'none',
4089                 'vcodec': 'none',
4090                 'url': url,
4091                 'width': width,
4092                 'height': height,
4093                 'fps': frame_count / duration,
4094                 'rows': rows,
4095                 'columns': cols,
4096                 'fragments': [{
4097                     'url': url.replace('$M', str(j)),
4098                     'duration': min(fragment_duration, duration - (j * fragment_duration)),
4099                 } for j in range(math.ceil(fragment_count))],
4100             }
4101
4102     def _download_player_responses(self, url, smuggled_data, video_id, webpage_url):
4103         webpage = None
4104         if 'webpage' not in self._configuration_arg('player_skip'):
4105             query = {'bpctr': '9999999999', 'has_verified': '1'}
4106             pp = self._configuration_arg('player_params', [None], casesense=True)[0]
4107             if pp:
4108                 query['pp'] = pp
4109             webpage = self._download_webpage(
4110                 webpage_url, video_id, fatal=False, query=query)
4111
4112         master_ytcfg = self.extract_ytcfg(video_id, webpage) or self._get_default_ytcfg()
4113
4114         player_responses, player_url = self._extract_player_responses(
4115             self._get_requested_clients(url, smuggled_data),
4116             video_id, webpage, master_ytcfg, smuggled_data)
4117
4118         return webpage, master_ytcfg, player_responses, player_url
4119
4120     def _list_formats(self, video_id, microformats, video_details, player_responses, player_url, duration=None):
4121         live_broadcast_details = traverse_obj(microformats, (..., 'liveBroadcastDetails'))
4122         is_live = get_first(video_details, 'isLive')
4123         if is_live is None:
4124             is_live = get_first(live_broadcast_details, 'isLiveNow')
4125         live_content = get_first(video_details, 'isLiveContent')
4126         is_upcoming = get_first(video_details, 'isUpcoming')
4127         post_live = get_first(video_details, 'isPostLiveDvr')
4128         live_status = ('post_live' if post_live
4129                        else 'is_live' if is_live
4130                        else 'is_upcoming' if is_upcoming
4131                        else 'was_live' if live_content
4132                        else 'not_live' if False in (is_live, live_content)
4133                        else None)
4134         streaming_data = traverse_obj(player_responses, (..., 'streamingData'))
4135         *formats, subtitles = self._extract_formats_and_subtitles(streaming_data, video_id, player_url, live_status, duration)
4136         if all(f.get('has_drm') for f in formats):
4137             # If there are no formats that definitely don't have DRM, all have DRM
4138             for f in formats:
4139                 f['has_drm'] = True
4140
4141         return live_broadcast_details, live_status, streaming_data, formats, subtitles
4142
4143     def _real_extract(self, url):
4144         url, smuggled_data = unsmuggle_url(url, {})
4145         video_id = self._match_id(url)
4146
4147         base_url = self.http_scheme() + '//www.youtube.com/'
4148         webpage_url = base_url + 'watch?v=' + video_id
4149
4150         webpage, master_ytcfg, player_responses, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
4151
4152         playability_statuses = traverse_obj(
4153             player_responses, (..., 'playabilityStatus'), expected_type=dict)
4154
4155         trailer_video_id = get_first(
4156             playability_statuses,
4157             ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4158             expected_type=str)
4159         if trailer_video_id:
4160             return self.url_result(
4161                 trailer_video_id, self.ie_key(), trailer_video_id)
4162
4163         search_meta = ((lambda x: self._html_search_meta(x, webpage, default=None))
4164                        if webpage else (lambda x: None))
4165
4166         video_details = traverse_obj(player_responses, (..., 'videoDetails'), expected_type=dict)
4167         microformats = traverse_obj(
4168             player_responses, (..., 'microformat', 'playerMicroformatRenderer'),
4169             expected_type=dict)
4170
4171         translated_title = self._get_text(microformats, (..., 'title'))
4172         video_title = (self._preferred_lang and translated_title
4173                        or get_first(video_details, 'title')  # primary
4174                        or translated_title
4175                        or search_meta(['og:title', 'twitter:title', 'title']))
4176         translated_description = self._get_text(microformats, (..., 'description'))
4177         original_description = get_first(video_details, 'shortDescription')
4178         video_description = (
4179             self._preferred_lang and translated_description
4180             # If original description is blank, it will be an empty string.
4181             # Do not prefer translated description in this case.
4182             or original_description if original_description is not None else translated_description)
4183
4184         multifeed_metadata_list = get_first(
4185             player_responses,
4186             ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4187             expected_type=str)
4188         if multifeed_metadata_list and not smuggled_data.get('force_singlefeed'):
4189             if self.get_param('noplaylist'):
4190                 self.to_screen(f'Downloading just video {video_id} because of --no-playlist')
4191             else:
4192                 entries = []
4193                 feed_ids = []
4194                 for feed in multifeed_metadata_list.split(','):
4195                     # Unquote should take place before split on comma (,) since textual
4196                     # fields may contain comma as well (see
4197                     # https://github.com/ytdl-org/youtube-dl/issues/8536)
4198                     feed_data = urllib.parse.parse_qs(
4199                         urllib.parse.unquote_plus(feed))
4200
4201                     def feed_entry(name):
4202                         return try_get(
4203                             feed_data, lambda x: x[name][0], str)
4204
4205                     feed_id = feed_entry('id')
4206                     if not feed_id:
4207                         continue
4208                     feed_title = feed_entry('title')
4209                     title = video_title
4210                     if feed_title:
4211                         title += f' ({feed_title})'
4212                     entries.append({
4213                         '_type': 'url_transparent',
4214                         'ie_key': 'Youtube',
4215                         'url': smuggle_url(
4216                             '{}watch?v={}'.format(base_url, feed_data['id'][0]),
4217                             {'force_singlefeed': True}),
4218                         'title': title,
4219                     })
4220                     feed_ids.append(feed_id)
4221                 self.to_screen(
4222                     'Downloading multifeed video ({}) - add --no-playlist to just download video {}'.format(
4223                         ', '.join(feed_ids), video_id))
4224                 return self.playlist_result(
4225                     entries, video_id, video_title, video_description)
4226
4227         duration = (int_or_none(get_first(video_details, 'lengthSeconds'))
4228                     or int_or_none(get_first(microformats, 'lengthSeconds'))
4229                     or parse_duration(search_meta('duration')) or None)
4230
4231         live_broadcast_details, live_status, streaming_data, formats, automatic_captions = \
4232             self._list_formats(video_id, microformats, video_details, player_responses, player_url, duration)
4233         if live_status == 'post_live':
4234             self.write_debug(f'{video_id}: Video is in Post-Live Manifestless mode')
4235
4236         if not formats:
4237             if not self.get_param('allow_unplayable_formats') and traverse_obj(streaming_data, (..., 'licenseInfos')):
4238                 self.report_drm(video_id)
4239             pemr = get_first(
4240                 playability_statuses,
4241                 ('errorScreen', 'playerErrorMessageRenderer'), expected_type=dict) or {}
4242             reason = self._get_text(pemr, 'reason') or get_first(playability_statuses, 'reason')
4243             subreason = clean_html(self._get_text(pemr, 'subreason') or '')
4244             if subreason:
4245                 if subreason == 'The uploader has not made this video available in your country.':
4246                     countries = get_first(microformats, 'availableCountries')
4247                     if not countries:
4248                         regions_allowed = search_meta('regionsAllowed')
4249                         countries = regions_allowed.split(',') if regions_allowed else None
4250                     self.raise_geo_restricted(subreason, countries, metadata_available=True)
4251                 reason += f'. {subreason}'
4252             if reason:
4253                 self.raise_no_formats(reason, expected=True)
4254
4255         keywords = get_first(video_details, 'keywords', expected_type=list) or []
4256         if not keywords and webpage:
4257             keywords = [
4258                 unescapeHTML(m.group('content'))
4259                 for m in re.finditer(self._meta_regex('og:video:tag'), webpage)]
4260         for keyword in keywords:
4261             if keyword.startswith('yt:stretch='):
4262                 mobj = re.search(r'(\d+)\s*:\s*(\d+)', keyword)
4263                 if mobj:
4264                     # NB: float is intentional for forcing float division
4265                     w, h = (float(v) for v in mobj.groups())
4266                     if w > 0 and h > 0:
4267                         ratio = w / h
4268                         for f in formats:
4269                             if f.get('vcodec') != 'none':
4270                                 f['stretched_ratio'] = ratio
4271                         break
4272         thumbnails = self._extract_thumbnails((video_details, microformats), (..., ..., 'thumbnail'))
4273         thumbnail_url = search_meta(['og:image', 'twitter:image'])
4274         if thumbnail_url:
4275             thumbnails.append({
4276                 'url': thumbnail_url,
4277             })
4278         original_thumbnails = thumbnails.copy()
4279
4280         # The best resolution thumbnails sometimes does not appear in the webpage
4281         # See: https://github.com/yt-dlp/yt-dlp/issues/340
4282         # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4283         thumbnail_names = [
4284             # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4285             # in resolution, these are not the custom thumbnail. So de-prioritize them
4286             'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4287             'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3',
4288         ]
4289         n_thumbnail_names = len(thumbnail_names)
4290         thumbnails.extend({
4291             'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4292                 video_id=video_id, name=name, ext=ext,
4293                 webp='_webp' if ext == 'webp' else '', live='_live' if live_status == 'is_live' else ''),
4294         } for name in thumbnail_names for ext in ('webp', 'jpg'))
4295         for thumb in thumbnails:
4296             i = next((i for i, t in enumerate(thumbnail_names) if f'/{video_id}/{t}' in thumb['url']), n_thumbnail_names)
4297             thumb['preference'] = (0 if '.webp' in thumb['url'] else -1) - (2 * i)
4298         self._remove_duplicate_formats(thumbnails)
4299         self._downloader._sort_thumbnails(original_thumbnails)
4300
4301         category = get_first(microformats, 'category') or search_meta('genre')
4302         channel_id = self.ucid_or_none(str_or_none(
4303             get_first(video_details, 'channelId')
4304             or get_first(microformats, 'externalChannelId')
4305             or search_meta('channelId')))
4306         owner_profile_url = get_first(microformats, 'ownerProfileUrl')
4307
4308         live_start_time = parse_iso8601(get_first(live_broadcast_details, 'startTimestamp'))
4309         live_end_time = parse_iso8601(get_first(live_broadcast_details, 'endTimestamp'))
4310         if not duration and live_end_time and live_start_time:
4311             duration = live_end_time - live_start_time
4312
4313         needs_live_processing = self._needs_live_processing(live_status, duration)
4314
4315         def is_bad_format(fmt):
4316             if needs_live_processing and not fmt.get('is_from_start'):
4317                 return True
4318             elif (live_status == 'is_live' and needs_live_processing != 'is_live'
4319                     and fmt.get('protocol') == 'http_dash_segments'):
4320                 return True
4321
4322         for fmt in filter(is_bad_format, formats):
4323             fmt['preference'] = (fmt.get('preference') or -1) - 10
4324             fmt['format_note'] = join_nonempty(fmt.get('format_note'), '(Last 2 hours)', delim=' ')
4325
4326         if needs_live_processing:
4327             self._prepare_live_from_start_formats(
4328                 formats, video_id, live_start_time, url, webpage_url, smuggled_data, live_status == 'is_live')
4329
4330         formats.extend(self._extract_storyboard(player_responses, duration))
4331
4332         channel_handle = self.handle_from_url(owner_profile_url)
4333
4334         info = {
4335             'id': video_id,
4336             'title': video_title,
4337             'formats': formats,
4338             'thumbnails': thumbnails,
4339             # The best thumbnail that we are sure exists. Prevents unnecessary
4340             # URL checking if user don't care about getting the best possible thumbnail
4341             'thumbnail': traverse_obj(original_thumbnails, (-1, 'url')),
4342             'description': video_description,
4343             'channel_id': channel_id,
4344             'channel_url': format_field(channel_id, None, 'https://www.youtube.com/channel/%s', default=None),
4345             'duration': duration,
4346             'view_count': int_or_none(
4347                 get_first((video_details, microformats), (..., 'viewCount'))
4348                 or search_meta('interactionCount')),
4349             'average_rating': float_or_none(get_first(video_details, 'averageRating')),
4350             'age_limit': 18 if (
4351                 get_first(microformats, 'isFamilySafe') is False
4352                 or search_meta('isFamilyFriendly') == 'false'
4353                 or search_meta('og:restrictions:age') == '18+') else 0,
4354             'webpage_url': webpage_url,
4355             'categories': [category] if category else None,
4356             'tags': keywords,
4357             'playable_in_embed': get_first(playability_statuses, 'playableInEmbed'),
4358             'live_status': live_status,
4359             'release_timestamp': live_start_time,
4360             '_format_sort_fields': (  # source_preference is lower for throttled/potentially damaged formats
4361                 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto'),
4362         }
4363
4364         subtitles = {}
4365         pctr = traverse_obj(player_responses, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type=dict)
4366         if pctr:
4367             def get_lang_code(track):
4368                 return (remove_start(track.get('vssId') or '', '.').replace('.', '-')
4369                         or track.get('languageCode'))
4370
4371             # Converted into dicts to remove duplicates
4372             captions = {
4373                 get_lang_code(sub): sub
4374                 for sub in traverse_obj(pctr, (..., 'captionTracks', ...))}
4375             translation_languages = {
4376                 lang.get('languageCode'): self._get_text(lang.get('languageName'), max_runs=1)
4377                 for lang in traverse_obj(pctr, (..., 'translationLanguages', ...))}
4378
4379             def process_language(container, base_url, lang_code, sub_name, query):
4380                 lang_subs = container.setdefault(lang_code, [])
4381                 for fmt in self._SUBTITLE_FORMATS:
4382                     query.update({
4383                         'fmt': fmt,
4384                     })
4385                     lang_subs.append({
4386                         'ext': fmt,
4387                         'url': urljoin('https://www.youtube.com', update_url_query(base_url, query)),
4388                         'name': sub_name,
4389                     })
4390
4391             # NB: Constructing the full subtitle dictionary is slow
4392             get_translated_subs = 'translated_subs' not in self._configuration_arg('skip') and (
4393                 self.get_param('writeautomaticsub', False) or self.get_param('listsubtitles'))
4394             for lang_code, caption_track in captions.items():
4395                 base_url = caption_track.get('baseUrl')
4396                 orig_lang = parse_qs(base_url).get('lang', [None])[-1]
4397                 if not base_url:
4398                     continue
4399                 lang_name = self._get_text(caption_track, 'name', max_runs=1)
4400                 if caption_track.get('kind') != 'asr':
4401                     if not lang_code:
4402                         continue
4403                     process_language(
4404                         subtitles, base_url, lang_code, lang_name, {})
4405                     if not caption_track.get('isTranslatable'):
4406                         continue
4407                 for trans_code, trans_name in translation_languages.items():
4408                     if not trans_code:
4409                         continue
4410                     orig_trans_code = trans_code
4411                     if caption_track.get('kind') != 'asr' and trans_code != 'und':
4412                         if not get_translated_subs:
4413                             continue
4414                         trans_code += f'-{lang_code}'
4415                         trans_name += format_field(lang_name, None, ' from %s')
4416                     if lang_code == f'a-{orig_trans_code}':
4417                         # Set audio language based on original subtitles
4418                         for f in formats:
4419                             if f.get('acodec') != 'none' and not f.get('language'):
4420                                 f['language'] = orig_trans_code
4421                         # Add an "-orig" label to the original language so that it can be distinguished.
4422                         # The subs are returned without "-orig" as well for compatibility
4423                         process_language(
4424                             automatic_captions, base_url, f'{trans_code}-orig', f'{trans_name} (Original)', {})
4425                     # Setting tlang=lang returns damaged subtitles.
4426                     process_language(automatic_captions, base_url, trans_code, trans_name,
4427                                      {} if orig_lang == orig_trans_code else {'tlang': trans_code})
4428
4429         info['automatic_captions'] = automatic_captions
4430         info['subtitles'] = subtitles
4431
4432         parsed_url = urllib.parse.urlparse(url)
4433         for component in [parsed_url.fragment, parsed_url.query]:
4434             query = urllib.parse.parse_qs(component)
4435             for k, v in query.items():
4436                 for d_k, s_ks in [('start', ('start', 't')), ('end', ('end',))]:
4437                     d_k += '_time'
4438                     if d_k not in info and k in s_ks:
4439                         info[d_k] = parse_duration(v[0])
4440
4441         # Youtube Music Auto-generated description
4442         if (video_description or '').strip().endswith('\nAuto-generated by YouTube.'):
4443             # XXX: Causes catastrophic backtracking if description has "·"
4444             # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4445             # Simulating atomic groups:  (?P<a>[^xy]+)x  =>  (?=(?P<a>[^xy]+))(?P=a)x
4446             # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4447             mobj = re.search(
4448                 r'''(?xs)
4449                     (?=(?P<track>[^\n·]+))(?P=track)·
4450                     (?=(?P<artist>[^\n]+))(?P=artist)\n+
4451                     (?=(?P<album>[^\n]+))(?P=album)\n
4452                     (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4453                     (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4454                     (.+?\nArtist\s*:\s*
4455                         (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4456                     )?.+\nAuto-generated\ by\ YouTube\.\s*$
4457                 ''', video_description)
4458             if mobj:
4459                 release_year = mobj.group('release_year')
4460                 release_date = mobj.group('release_date')
4461                 if release_date:
4462                     release_date = release_date.replace('-', '')
4463                     if not release_year:
4464                         release_year = release_date[:4]
4465                 info.update({
4466                     'album': mobj.group('album'.strip()),
4467                     'artists': ([a] if (a := mobj.group('clean_artist'))
4468                                 else [a.strip() for a in mobj.group('artist').split('·')]),
4469                     'track': mobj.group('track').strip(),
4470                     'release_date': release_date,
4471                     'release_year': int_or_none(release_year),
4472                 })
4473
4474         initial_data = None
4475         if webpage:
4476             initial_data = self.extract_yt_initial_data(video_id, webpage, fatal=False)
4477             if not traverse_obj(initial_data, 'contents'):
4478                 self.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4479                 initial_data = None
4480         if not initial_data:
4481             query = {'videoId': video_id}
4482             query.update(self._get_checkok_params())
4483             initial_data = self._extract_response(
4484                 item_id=video_id, ep='next', fatal=False,
4485                 ytcfg=master_ytcfg, query=query, check_get_keys='contents',
4486                 headers=self.generate_api_headers(ytcfg=master_ytcfg),
4487                 note='Downloading initial data API JSON')
4488
4489         info['comment_count'] = traverse_obj(initial_data, (
4490             'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4491             'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount',
4492         ), (
4493             'engagementPanels', lambda _, v: v['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4494             'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo',
4495         ), expected_type=self._get_count, get_all=False)
4496
4497         try:  # This will error if there is no livechat
4498             initial_data['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4499         except (KeyError, IndexError, TypeError):
4500             pass
4501         else:
4502             info.setdefault('subtitles', {})['live_chat'] = [{
4503                 # url is needed to set cookies
4504                 'url': f'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4505                 'video_id': video_id,
4506                 'ext': 'json',
4507                 'protocol': ('youtube_live_chat' if live_status in ('is_live', 'is_upcoming')
4508                              else 'youtube_live_chat_replay'),
4509             }]
4510
4511         if initial_data:
4512             info['chapters'] = (
4513                 self._extract_chapters_from_json(initial_data, duration)
4514                 or self._extract_chapters_from_engagement_panel(initial_data, duration)
4515                 or self._extract_chapters_from_description(video_description, duration)
4516                 or None)
4517
4518             info['heatmap'] = self._extract_heatmap(initial_data)
4519
4520         contents = traverse_obj(
4521             initial_data, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4522             expected_type=list, default=[])
4523
4524         vpir = get_first(contents, 'videoPrimaryInfoRenderer')
4525         if vpir:
4526             stl = vpir.get('superTitleLink')
4527             if stl:
4528                 stl = self._get_text(stl)
4529                 if try_get(
4530                         vpir,
4531                         lambda x: x['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4532                     info['location'] = stl
4533                 else:
4534                     mobj = re.search(r'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl)
4535                     if mobj:
4536                         info.update({
4537                             'series': mobj.group(1),
4538                             'season_number': int(mobj.group(2)),
4539                             'episode_number': int(mobj.group(3)),
4540                         })
4541             for tlb in (try_get(
4542                     vpir,
4543                     lambda x: x['videoActions']['menuRenderer']['topLevelButtons'],
4544                     list) or []):
4545                 tbrs = variadic(
4546                     traverse_obj(
4547                         tlb, ('toggleButtonRenderer', ...),
4548                         ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4549                 for tbr in tbrs:
4550                     for getter, regex in [(
4551                             lambda x: x['defaultText']['accessibility']['accessibilityData'],
4552                             r'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4553                                 lambda x: x['accessibility'],
4554                                 lambda x: x['accessibilityData']['accessibilityData'],
4555                             ], r'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4556                         label = (try_get(tbr, getter, dict) or {}).get('label')
4557                         if label:
4558                             mobj = re.match(regex, label)
4559                             if mobj:
4560                                 info[mobj.group('type') + '_count'] = str_to_int(mobj.group('count'))
4561                                 break
4562
4563             info['like_count'] = traverse_obj(vpir, (
4564                 'videoActions', 'menuRenderer', 'topLevelButtons', ...,
4565                 'segmentedLikeDislikeButtonViewModel', 'likeButtonViewModel', 'likeButtonViewModel',
4566                 'toggleButtonViewModel', 'toggleButtonViewModel', 'defaultButtonViewModel',
4567                 'buttonViewModel', 'accessibilityText', {parse_count}), get_all=False)
4568
4569             vcr = traverse_obj(vpir, ('viewCount', 'videoViewCountRenderer'))
4570             if vcr:
4571                 vc = self._get_count(vcr, 'viewCount')
4572                 # Upcoming premieres with waiting count are treated as live here
4573                 if vcr.get('isLive'):
4574                     info['concurrent_view_count'] = vc
4575                 elif info.get('view_count') is None:
4576                     info['view_count'] = vc
4577
4578         vsir = get_first(contents, 'videoSecondaryInfoRenderer')
4579         if vsir:
4580             vor = traverse_obj(vsir, ('owner', 'videoOwnerRenderer'))
4581             info.update({
4582                 'channel': self._get_text(vor, 'title'),
4583                 'channel_follower_count': self._get_count(vor, 'subscriberCountText')})
4584
4585             if not channel_handle:
4586                 channel_handle = self.handle_from_url(
4587                     traverse_obj(vor, (
4588                         ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4589                         (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4590                         {str}), get_all=False))
4591
4592             rows = try_get(
4593                 vsir,
4594                 lambda x: x['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4595                 list) or []
4596             multiple_songs = False
4597             for row in rows:
4598                 if try_get(row, lambda x: x['metadataRowRenderer']['hasDividerLine']) is True:
4599                     multiple_songs = True
4600                     break
4601             for row in rows:
4602                 mrr = row.get('metadataRowRenderer') or {}
4603                 mrr_title = mrr.get('title')
4604                 if not mrr_title:
4605                     continue
4606                 mrr_title = self._get_text(mrr, 'title')
4607                 mrr_contents_text = self._get_text(mrr, ('contents', 0))
4608                 if mrr_title == 'License':
4609                     info['license'] = mrr_contents_text
4610                 elif not multiple_songs:
4611                     if mrr_title == 'Album':
4612                         info['album'] = mrr_contents_text
4613                     elif mrr_title == 'Artist':
4614                         info['artists'] = [mrr_contents_text] if mrr_contents_text else None
4615                     elif mrr_title == 'Song':
4616                         info['track'] = mrr_contents_text
4617             owner_badges = self._extract_badges(traverse_obj(vsir, ('owner', 'videoOwnerRenderer', 'badges')))
4618             if self._has_badge(owner_badges, BadgeType.VERIFIED):
4619                 info['channel_is_verified'] = True
4620
4621         info.update({
4622             'uploader': info.get('channel'),
4623             'uploader_id': channel_handle,
4624             'uploader_url': format_field(channel_handle, None, 'https://www.youtube.com/%s', default=None),
4625         })
4626
4627         # We only want timestamp IF it has time precision AND a timezone
4628         # Currently the uploadDate in microformats appears to be in US/Pacific timezone.
4629         timestamp = (
4630             parse_iso8601(get_first(microformats, 'uploadDate'), timezone=NO_DEFAULT)
4631             or parse_iso8601(search_meta('uploadDate'), timezone=NO_DEFAULT)
4632         )
4633         upload_date = (
4634             dt.datetime.fromtimestamp(timestamp, dt.timezone.utc).strftime('%Y%m%d') if timestamp else
4635             (
4636                 unified_strdate(get_first(microformats, 'uploadDate'))
4637                 or unified_strdate(search_meta('uploadDate'))
4638             ))
4639
4640         # In the case we cannot get the timestamp:
4641         # The upload date for scheduled, live and past live streams / premieres in microformats
4642         # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4643         # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4644         if not upload_date or (not timestamp and live_status in ('not_live', None)):
4645             # this should be in UTC, as configured in the cookie/client context
4646             upload_date = strftime_or_none(
4647                 self._parse_time_text(self._get_text(vpir, 'dateText'))) or upload_date
4648
4649         info['upload_date'] = upload_date
4650         info['timestamp'] = timestamp
4651
4652         if upload_date and live_status not in ('is_live', 'post_live', 'is_upcoming'):
4653             # Newly uploaded videos' HLS formats are potentially problematic and need to be checked
4654             upload_datetime = datetime_from_str(upload_date).replace(tzinfo=dt.timezone.utc)
4655             if upload_datetime >= datetime_from_str('today-2days'):
4656                 for fmt in info['formats']:
4657                     if fmt.get('protocol') == 'm3u8_native':
4658                         fmt['__needs_testing'] = True
4659
4660         for s_k, d_k in [('artists', 'creators'), ('track', 'alt_title')]:
4661             v = info.get(s_k)
4662             if v:
4663                 info[d_k] = v
4664
4665         badges = self._extract_badges(traverse_obj(vpir, 'badges'))
4666
4667         is_private = (self._has_badge(badges, BadgeType.AVAILABILITY_PRIVATE)
4668                       or get_first(video_details, 'isPrivate', expected_type=bool))
4669
4670         info['availability'] = (
4671             'public' if self._has_badge(badges, BadgeType.AVAILABILITY_PUBLIC)
4672             else self._availability(
4673                 is_private=is_private,
4674                 needs_premium=(
4675                     self._has_badge(badges, BadgeType.AVAILABILITY_PREMIUM)
4676                     or False if initial_data and is_private is not None else None),
4677                 needs_subscription=(
4678                     self._has_badge(badges, BadgeType.AVAILABILITY_SUBSCRIPTION)
4679                     or False if initial_data and is_private is not None else None),
4680                 needs_auth=info['age_limit'] >= 18,
4681                 is_unlisted=None if is_private is None else (
4682                     self._has_badge(badges, BadgeType.AVAILABILITY_UNLISTED)
4683                     or get_first(microformats, 'isUnlisted', expected_type=bool))))
4684
4685         info['__post_extractor'] = self.extract_comments(master_ytcfg, video_id, contents, webpage)
4686
4687         self.mark_watched(video_id, player_responses)
4688
4689         return info
4690
4691
4692 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor):
4693     @staticmethod
4694     def passthrough_smuggled_data(func):
4695         def _smuggle(info, smuggled_data):
4696             if info.get('_type') not in ('url', 'url_transparent'):
4697                 return info
4698             if smuggled_data.get('is_music_url'):
4699                 parsed_url = urllib.parse.urlparse(info['url'])
4700                 if parsed_url.netloc in ('www.youtube.com', 'music.youtube.com'):
4701                     smuggled_data.pop('is_music_url')
4702                     info['url'] = urllib.parse.urlunparse(parsed_url._replace(netloc='music.youtube.com'))
4703             if smuggled_data:
4704                 info['url'] = smuggle_url(info['url'], smuggled_data)
4705             return info
4706
4707         @functools.wraps(func)
4708         def wrapper(self, url):
4709             url, smuggled_data = unsmuggle_url(url, {})
4710             if self.is_music_url(url):
4711                 smuggled_data['is_music_url'] = True
4712             info_dict = func(self, url, smuggled_data)
4713             if smuggled_data:
4714                 _smuggle(info_dict, smuggled_data)
4715                 if info_dict.get('entries'):
4716                     info_dict['entries'] = (_smuggle(i, smuggled_data.copy()) for i in info_dict['entries'])
4717             return info_dict
4718         return wrapper
4719
4720     @staticmethod
4721     def _extract_basic_item_renderer(item):
4722         # Modified from _extract_grid_item_renderer
4723         known_basic_renderers = (
4724             'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer',
4725         )
4726         for key, renderer in item.items():
4727             if not isinstance(renderer, dict):
4728                 continue
4729             elif key in known_basic_renderers:
4730                 return renderer
4731             elif key.startswith('grid') and key.endswith('Renderer'):
4732                 return renderer
4733
4734     def _extract_channel_renderer(self, renderer):
4735         channel_id = self.ucid_or_none(renderer['channelId'])
4736         title = self._get_text(renderer, 'title')
4737         channel_url = format_field(channel_id, None, 'https://www.youtube.com/channel/%s', default=None)
4738         channel_handle = self.handle_from_url(
4739             traverse_obj(renderer, (
4740                 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4741                                        ('browseEndpoint', 'canonicalBaseUrl')),
4742                 {str}), get_all=False))
4743         if not channel_handle:
4744             # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4745             channel_handle = self.handle_or_none(self._get_text(renderer, 'subscriberCountText'))
4746         return {
4747             '_type': 'url',
4748             'url': channel_url,
4749             'id': channel_id,
4750             'ie_key': YoutubeTabIE.ie_key(),
4751             'channel': title,
4752             'uploader': title,
4753             'channel_id': channel_id,
4754             'channel_url': channel_url,
4755             'title': title,
4756             'uploader_id': channel_handle,
4757             'uploader_url': format_field(channel_handle, None, 'https://www.youtube.com/%s', default=None),
4758             # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4759             # However, in feed/channels this is set correctly to the subscriber count
4760             'channel_follower_count': traverse_obj(
4761                 renderer, 'subscriberCountText', 'videoCountText', expected_type=self._get_count),
4762             'thumbnails': self._extract_thumbnails(renderer, 'thumbnail'),
4763             'playlist_count': (
4764                 # videoCountText may be the subscriber count
4765                 self._get_count(renderer, 'videoCountText')
4766                 if self._get_count(renderer, 'subscriberCountText') is not None else None),
4767             'description': self._get_text(renderer, 'descriptionSnippet'),
4768             'channel_is_verified': True if self._has_badge(
4769                 self._extract_badges(traverse_obj(renderer, 'ownerBadges')), BadgeType.VERIFIED) else None,
4770         }
4771
4772     def _grid_entries(self, grid_renderer):
4773         for item in grid_renderer['items']:
4774             if not isinstance(item, dict):
4775                 continue
4776             renderer = self._extract_basic_item_renderer(item)
4777             if not isinstance(renderer, dict):
4778                 continue
4779             title = self._get_text(renderer, 'title')
4780
4781             # playlist
4782             playlist_id = renderer.get('playlistId')
4783             if playlist_id:
4784                 yield self.url_result(
4785                     f'https://www.youtube.com/playlist?list={playlist_id}',
4786                     ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
4787                     video_title=title)
4788                 continue
4789             # video
4790             video_id = renderer.get('videoId')
4791             if video_id:
4792                 yield self._extract_video(renderer)
4793                 continue
4794             # channel
4795             channel_id = renderer.get('channelId')
4796             if channel_id:
4797                 yield self._extract_channel_renderer(renderer)
4798                 continue
4799             # generic endpoint URL support
4800             ep_url = urljoin('https://www.youtube.com/', try_get(
4801                 renderer, lambda x: x['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4802                 str))
4803             if ep_url:
4804                 for ie in (YoutubeTabIE, YoutubePlaylistIE, YoutubeIE):
4805                     if ie.suitable(ep_url):
4806                         yield self.url_result(
4807                             ep_url, ie=ie.ie_key(), video_id=ie._match_id(ep_url), video_title=title)
4808                         break
4809
4810     def _music_reponsive_list_entry(self, renderer):
4811         video_id = traverse_obj(renderer, ('playlistItemData', 'videoId'))
4812         if video_id:
4813             title = traverse_obj(renderer, (
4814                 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4815                 'text', 'runs', 0, 'text'))
4816             return self.url_result(f'https://music.youtube.com/watch?v={video_id}',
4817                                    ie=YoutubeIE.ie_key(), video_id=video_id, title=title)
4818         playlist_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4819         if playlist_id:
4820             video_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4821             if video_id:
4822                 return self.url_result(f'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4823                                        ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
4824             return self.url_result(f'https://music.youtube.com/playlist?list={playlist_id}',
4825                                    ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
4826         browse_id = traverse_obj(renderer, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4827         if browse_id:
4828             return self.url_result(f'https://music.youtube.com/browse/{browse_id}',
4829                                    ie=YoutubeTabIE.ie_key(), video_id=browse_id)
4830
4831     def _shelf_entries_from_content(self, shelf_renderer):
4832         content = shelf_renderer.get('content')
4833         if not isinstance(content, dict):
4834             return
4835         renderer = content.get('gridRenderer') or content.get('expandedShelfContentsRenderer')
4836         if renderer:
4837             # TODO: add support for nested playlists so each shelf is processed
4838             # as separate playlist
4839             # TODO: this includes only first N items
4840             yield from self._grid_entries(renderer)
4841         renderer = content.get('horizontalListRenderer')
4842         if renderer:
4843             # TODO: handle case
4844             pass
4845
4846     def _shelf_entries(self, shelf_renderer, skip_channels=False):
4847         ep = try_get(
4848             shelf_renderer, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4849             str)
4850         shelf_url = urljoin('https://www.youtube.com', ep)
4851         if shelf_url:
4852             # Skipping links to another channels, note that checking for
4853             # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4854             # will not work
4855             if skip_channels and '/channels?' in shelf_url:
4856                 return
4857             title = self._get_text(shelf_renderer, 'title')
4858             yield self.url_result(shelf_url, video_title=title)
4859         # Shelf may not contain shelf URL, fallback to extraction from content
4860         yield from self._shelf_entries_from_content(shelf_renderer)
4861
4862     def _playlist_entries(self, video_list_renderer):
4863         for content in video_list_renderer['contents']:
4864             if not isinstance(content, dict):
4865                 continue
4866             renderer = content.get('playlistVideoRenderer') or content.get('playlistPanelVideoRenderer')
4867             if not isinstance(renderer, dict):
4868                 continue
4869             video_id = renderer.get('videoId')
4870             if not video_id:
4871                 continue
4872             yield self._extract_video(renderer)
4873
4874     def _rich_entries(self, rich_grid_renderer):
4875         renderer = traverse_obj(
4876             rich_grid_renderer,
4877             ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all=False) or {}
4878         video_id = renderer.get('videoId')
4879         if video_id:
4880             yield self._extract_video(renderer)
4881             return
4882         playlist_id = renderer.get('playlistId')
4883         if playlist_id:
4884             yield self.url_result(
4885                 f'https://www.youtube.com/playlist?list={playlist_id}',
4886                 ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
4887                 video_title=self._get_text(renderer, 'title'))
4888             return
4889
4890     def _video_entry(self, video_renderer):
4891         video_id = video_renderer.get('videoId')
4892         if video_id:
4893             return self._extract_video(video_renderer)
4894
4895     def _hashtag_tile_entry(self, hashtag_tile_renderer):
4896         url = urljoin('https://youtube.com', traverse_obj(
4897             hashtag_tile_renderer, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4898         if url:
4899             return self.url_result(
4900                 url, ie=YoutubeTabIE.ie_key(), title=self._get_text(hashtag_tile_renderer, 'hashtag'))
4901
4902     def _post_thread_entries(self, post_thread_renderer):
4903         post_renderer = try_get(
4904             post_thread_renderer, lambda x: x['post']['backstagePostRenderer'], dict)
4905         if not post_renderer:
4906             return
4907         # video attachment
4908         video_renderer = try_get(
4909             post_renderer, lambda x: x['backstageAttachment']['videoRenderer'], dict) or {}
4910         video_id = video_renderer.get('videoId')
4911         if video_id:
4912             entry = self._extract_video(video_renderer)
4913             if entry:
4914                 yield entry
4915         # playlist attachment
4916         playlist_id = try_get(
4917             post_renderer, lambda x: x['backstageAttachment']['playlistRenderer']['playlistId'], str)
4918         if playlist_id:
4919             yield self.url_result(
4920                 f'https://www.youtube.com/playlist?list={playlist_id}',
4921                 ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
4922         # inline video links
4923         runs = try_get(post_renderer, lambda x: x['contentText']['runs'], list) or []
4924         for run in runs:
4925             if not isinstance(run, dict):
4926                 continue
4927             ep_url = try_get(
4928                 run, lambda x: x['navigationEndpoint']['urlEndpoint']['url'], str)
4929             if not ep_url:
4930                 continue
4931             if not YoutubeIE.suitable(ep_url):
4932                 continue
4933             ep_video_id = YoutubeIE._match_id(ep_url)
4934             if video_id == ep_video_id:
4935                 continue
4936             yield self.url_result(ep_url, ie=YoutubeIE.ie_key(), video_id=ep_video_id)
4937
4938     def _post_thread_continuation_entries(self, post_thread_continuation):
4939         contents = post_thread_continuation.get('contents')
4940         if not isinstance(contents, list):
4941             return
4942         for content in contents:
4943             renderer = content.get('backstagePostThreadRenderer')
4944             if isinstance(renderer, dict):
4945                 yield from self._post_thread_entries(renderer)
4946                 continue
4947             renderer = content.get('videoRenderer')
4948             if isinstance(renderer, dict):
4949                 yield self._video_entry(renderer)
4950
4951     r''' # unused
4952     def _rich_grid_entries(self, contents):
4953         for content in contents:
4954             video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4955             if video_renderer:
4956                 entry = self._video_entry(video_renderer)
4957                 if entry:
4958                     yield entry
4959     '''
4960
4961     def _report_history_entries(self, renderer):
4962         for url in traverse_obj(renderer, (
4963                 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4964                 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4965                 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4966             yield self.url_result(urljoin('https://www.youtube.com', url), YoutubeIE)
4967
4968     def _extract_entries(self, parent_renderer, continuation_list):
4969         # continuation_list is modified in-place with continuation_list = [continuation_token]
4970         continuation_list[:] = [None]
4971         contents = try_get(parent_renderer, lambda x: x['contents'], list) or []
4972         for content in contents:
4973             if not isinstance(content, dict):
4974                 continue
4975             is_renderer = traverse_obj(
4976                 content, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4977                 expected_type=dict)
4978             if not is_renderer:
4979                 if content.get('richItemRenderer'):
4980                     for entry in self._rich_entries(content['richItemRenderer']):
4981                         yield entry
4982                     continuation_list[0] = self._extract_continuation(parent_renderer)
4983                 elif content.get('reportHistorySectionRenderer'):  # https://www.youtube.com/reporthistory
4984                     table = traverse_obj(content, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4985                     yield from self._report_history_entries(table)
4986                     continuation_list[0] = self._extract_continuation(table)
4987                 continue
4988
4989             isr_contents = try_get(is_renderer, lambda x: x['contents'], list) or []
4990             for isr_content in isr_contents:
4991                 if not isinstance(isr_content, dict):
4992                     continue
4993
4994                 known_renderers = {
4995                     'playlistVideoListRenderer': self._playlist_entries,
4996                     'gridRenderer': self._grid_entries,
4997                     'reelShelfRenderer': self._grid_entries,
4998                     'shelfRenderer': self._shelf_entries,
4999                     'musicResponsiveListItemRenderer': lambda x: [self._music_reponsive_list_entry(x)],
5000                     'backstagePostThreadRenderer': self._post_thread_entries,
5001                     'videoRenderer': lambda x: [self._video_entry(x)],
5002                     'playlistRenderer': lambda x: self._grid_entries({'items': [{'playlistRenderer': x}]}),
5003                     'channelRenderer': lambda x: self._grid_entries({'items': [{'channelRenderer': x}]}),
5004                     'hashtagTileRenderer': lambda x: [self._hashtag_tile_entry(x)],
5005                     'richGridRenderer': lambda x: self._extract_entries(x, continuation_list),
5006                 }
5007                 for key, renderer in isr_content.items():
5008                     if key not in known_renderers:
5009                         continue
5010                     for entry in known_renderers[key](renderer):
5011                         if entry:
5012                             yield entry
5013                     continuation_list[0] = self._extract_continuation(renderer)
5014                     break
5015
5016             if not continuation_list[0]:
5017                 continuation_list[0] = self._extract_continuation(is_renderer)
5018
5019         if not continuation_list[0]:
5020             continuation_list[0] = self._extract_continuation(parent_renderer)
5021
5022     def _entries(self, tab, item_id, ytcfg, account_syncid, visitor_data):
5023         continuation_list = [None]
5024         extract_entries = lambda x: self._extract_entries(x, continuation_list)
5025         tab_content = try_get(tab, lambda x: x['content'], dict)
5026         if not tab_content:
5027             return
5028         parent_renderer = (
5029             try_get(tab_content, lambda x: x['sectionListRenderer'], dict)
5030             or try_get(tab_content, lambda x: x['richGridRenderer'], dict) or {})
5031         yield from extract_entries(parent_renderer)
5032         continuation = continuation_list[0]
5033         seen_continuations = set()
5034         for page_num in itertools.count(1):
5035             if not continuation:
5036                 break
5037             continuation_token = continuation.get('continuation')
5038             if continuation_token is not None and continuation_token in seen_continuations:
5039                 self.write_debug('Detected YouTube feed looping - assuming end of feed.')
5040                 break
5041             seen_continuations.add(continuation_token)
5042             headers = self.generate_api_headers(
5043                 ytcfg=ytcfg, account_syncid=account_syncid, visitor_data=visitor_data)
5044             response = self._extract_response(
5045                 item_id=f'{item_id} page {page_num}',
5046                 query=continuation, headers=headers, ytcfg=ytcfg,
5047                 check_get_keys=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
5048
5049             if not response:
5050                 break
5051             # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
5052             # See: https://github.com/ytdl-org/youtube-dl/issues/28702
5053             visitor_data = self._extract_visitor_data(response) or visitor_data
5054
5055             known_renderers = {
5056                 'videoRenderer': (self._grid_entries, 'items'),  # for membership tab
5057                 'gridPlaylistRenderer': (self._grid_entries, 'items'),
5058                 'gridVideoRenderer': (self._grid_entries, 'items'),
5059                 'gridChannelRenderer': (self._grid_entries, 'items'),
5060                 'playlistVideoRenderer': (self._playlist_entries, 'contents'),
5061                 'itemSectionRenderer': (extract_entries, 'contents'),  # for feeds
5062                 'richItemRenderer': (extract_entries, 'contents'),  # for hashtag
5063                 'backstagePostThreadRenderer': (self._post_thread_continuation_entries, 'contents'),
5064                 'reportHistoryTableRowRenderer': (self._report_history_entries, 'rows'),
5065                 'playlistVideoListContinuation': (self._playlist_entries, None),
5066                 'gridContinuation': (self._grid_entries, None),
5067                 'itemSectionContinuation': (self._post_thread_continuation_entries, None),
5068                 'sectionListContinuation': (extract_entries, None),  # for feeds
5069             }
5070
5071             continuation_items = traverse_obj(response, (
5072                 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
5073                 'appendContinuationItemsAction', 'continuationItems',
5074             ), 'continuationContents', get_all=False)
5075             continuation_item = traverse_obj(continuation_items, 0, None, expected_type=dict, default={})
5076
5077             video_items_renderer = None
5078             for key in continuation_item:
5079                 if key not in known_renderers:
5080                     continue
5081                 func, parent_key = known_renderers[key]
5082                 video_items_renderer = {parent_key: continuation_items} if parent_key else continuation_items
5083                 continuation_list = [None]
5084                 yield from func(video_items_renderer)
5085                 continuation = continuation_list[0] or self._extract_continuation(video_items_renderer)
5086
5087             if not video_items_renderer:
5088                 break
5089
5090     @staticmethod
5091     def _extract_selected_tab(tabs, fatal=True):
5092         for tab_renderer in tabs:
5093             if tab_renderer.get('selected'):
5094                 return tab_renderer
5095         if fatal:
5096             raise ExtractorError('Unable to find selected tab')
5097
5098     @staticmethod
5099     def _extract_tab_renderers(response):
5100         return traverse_obj(
5101             response, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type=dict)
5102
5103     def _extract_from_tabs(self, item_id, ytcfg, data, tabs):
5104         metadata = self._extract_metadata_from_tabs(item_id, data)
5105
5106         selected_tab = self._extract_selected_tab(tabs)
5107         metadata['title'] += format_field(selected_tab, 'title', ' - %s')
5108         metadata['title'] += format_field(selected_tab, 'expandedText', ' - %s')
5109
5110         return self.playlist_result(
5111             self._entries(
5112                 selected_tab, metadata['id'], ytcfg,
5113                 self._extract_account_syncid(ytcfg, data),
5114                 self._extract_visitor_data(data, ytcfg)),
5115             **metadata)
5116
5117     def _extract_metadata_from_tabs(self, item_id, data):
5118         info = {'id': item_id}
5119
5120         metadata_renderer = traverse_obj(data, ('metadata', 'channelMetadataRenderer'), expected_type=dict)
5121         if metadata_renderer:
5122             channel_id = traverse_obj(metadata_renderer, ('externalId', {self.ucid_or_none}),
5123                                       ('channelUrl', {self.ucid_from_url}))
5124             info.update({
5125                 'channel': metadata_renderer.get('title'),
5126                 'channel_id': channel_id,
5127             })
5128             if info['channel_id']:
5129                 info['id'] = info['channel_id']
5130         else:
5131             metadata_renderer = traverse_obj(data, ('metadata', 'playlistMetadataRenderer'), expected_type=dict)
5132
5133         # pageHeaderViewModel slow rollout began April 2024
5134         page_header_view_model = traverse_obj(data, (
5135             'header', 'pageHeaderRenderer', 'content', 'pageHeaderViewModel', {dict}))
5136
5137         # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5138         # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5139         def _get_uncropped(url):
5140             return url_or_none((url or '').split('=')[0] + '=s0')
5141
5142         avatar_thumbnails = self._extract_thumbnails(metadata_renderer, 'avatar')
5143         if avatar_thumbnails:
5144             uncropped_avatar = _get_uncropped(avatar_thumbnails[0]['url'])
5145             if uncropped_avatar:
5146                 avatar_thumbnails.append({
5147                     'url': uncropped_avatar,
5148                     'id': 'avatar_uncropped',
5149                     'preference': 1,
5150                 })
5151
5152         channel_banners = (
5153             self._extract_thumbnails(data, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5154             or self._extract_thumbnails(
5155                 page_header_view_model, ('banner', 'imageBannerViewModel', 'image'), final_key='sources'))
5156         for banner in channel_banners:
5157             banner['preference'] = -10
5158
5159         if channel_banners:
5160             uncropped_banner = _get_uncropped(channel_banners[0]['url'])
5161             if uncropped_banner:
5162                 channel_banners.append({
5163                     'url': uncropped_banner,
5164                     'id': 'banner_uncropped',
5165                     'preference': -5,
5166                 })
5167
5168         # Deprecated - remove primary_sidebar_renderer when layout discontinued
5169         primary_sidebar_renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer')
5170         playlist_header_renderer = traverse_obj(data, ('header', 'playlistHeaderRenderer'), expected_type=dict)
5171
5172         primary_thumbnails = self._extract_thumbnails(
5173             primary_sidebar_renderer, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5174         playlist_thumbnails = self._extract_thumbnails(
5175             playlist_header_renderer, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5176
5177         info.update({
5178             'title': (traverse_obj(metadata_renderer, 'title')
5179                       or self._get_text(data, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5180                       or info['id']),
5181             'availability': self._extract_availability(data),
5182             'channel_follower_count': (
5183                 self._get_count(data, ('header', ..., 'subscriberCountText'))
5184                 or traverse_obj(page_header_view_model, (
5185                     'metadata', 'contentMetadataViewModel', 'metadataRows', ..., 'metadataParts',
5186                     lambda _, v: 'subscribers' in v['text']['content'], 'text', 'content', {parse_count}, any))),
5187             'description': try_get(metadata_renderer, lambda x: x.get('description', '')),
5188             'tags': (traverse_obj(data, ('microformat', 'microformatDataRenderer', 'tags', ..., {str}))
5189                      or traverse_obj(metadata_renderer, ('keywords', {lambda x: x and shlex.split(x)}, ...))),
5190             'thumbnails': (primary_thumbnails or playlist_thumbnails) + avatar_thumbnails + channel_banners,
5191         })
5192
5193         channel_handle = (
5194             traverse_obj(metadata_renderer, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}), get_all=False)
5195             or traverse_obj(data, ('header', ..., 'channelHandleText', {self.handle_or_none}), get_all=False))
5196
5197         if channel_handle:
5198             info.update({
5199                 'uploader_id': channel_handle,
5200                 'uploader_url': format_field(channel_handle, None, 'https://www.youtube.com/%s', default=None),
5201             })
5202
5203         channel_badges = self._extract_badges(traverse_obj(data, ('header', ..., 'badges'), get_all=False))
5204         if self._has_badge(channel_badges, BadgeType.VERIFIED):
5205             info['channel_is_verified'] = True
5206         # Playlist stats is a text runs array containing [video count, view count, last updated].
5207         # last updated or (view count and last updated) may be missing.
5208         playlist_stats = get_first(
5209             (primary_sidebar_renderer, playlist_header_renderer), (('stats', 'briefStats', 'numVideosText'), ))
5210
5211         last_updated_unix = self._parse_time_text(
5212             self._get_text(playlist_stats, 2)  # deprecated, remove when old layout discontinued
5213             or self._get_text(playlist_header_renderer, ('byline', 1, 'playlistBylineRenderer', 'text')))
5214         info['modified_date'] = strftime_or_none(last_updated_unix)
5215
5216         info['view_count'] = self._get_count(playlist_stats, 1)
5217         if info['view_count'] is None:  # 0 is allowed
5218             info['view_count'] = self._get_count(playlist_header_renderer, 'viewCountText')
5219         if info['view_count'] is None:
5220             info['view_count'] = self._get_count(data, (
5221                 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5222                 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5223
5224         info['playlist_count'] = self._get_count(playlist_stats, 0)
5225         if info['playlist_count'] is None:  # 0 is allowed
5226             info['playlist_count'] = self._get_count(playlist_header_renderer, ('byline', 0, 'playlistBylineRenderer', 'text'))
5227
5228         if not info.get('channel_id'):
5229             owner = traverse_obj(playlist_header_renderer, 'ownerText')
5230             if not owner:  # Deprecated
5231                 owner = traverse_obj(
5232                     self._extract_sidebar_info_renderer(data, 'playlistSidebarSecondaryInfoRenderer'),
5233                     ('videoOwner', 'videoOwnerRenderer', 'title'))
5234             owner_text = self._get_text(owner)
5235             browse_ep = traverse_obj(owner, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5236             info.update({
5237                 'channel': self._search_regex(r'^by (.+) and \d+ others?$', owner_text, 'uploader', default=owner_text),
5238                 'channel_id': self.ucid_or_none(browse_ep.get('browseId')),
5239                 'uploader_id': self.handle_from_url(urljoin('https://www.youtube.com', browse_ep.get('canonicalBaseUrl'))),
5240             })
5241
5242         info.update({
5243             'uploader': info['channel'],
5244             'channel_url': format_field(info.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default=None),
5245             'uploader_url': format_field(info.get('uploader_id'), None, 'https://www.youtube.com/%s', default=None),
5246         })
5247
5248         return info
5249
5250     def _extract_inline_playlist(self, playlist, playlist_id, data, ytcfg):
5251         first_id = last_id = response = None
5252         for page_num in itertools.count(1):
5253             videos = list(self._playlist_entries(playlist))
5254             if not videos:
5255                 return
5256             start = next((i for i, v in enumerate(videos) if v['id'] == last_id), -1) + 1
5257             if start >= len(videos):
5258                 return
5259             yield from videos[start:]
5260             first_id = first_id or videos[0]['id']
5261             last_id = videos[-1]['id']
5262             watch_endpoint = try_get(
5263                 playlist, lambda x: x['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5264             headers = self.generate_api_headers(
5265                 ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
5266                 visitor_data=self._extract_visitor_data(response, data, ytcfg))
5267             query = {
5268                 'playlistId': playlist_id,
5269                 'videoId': watch_endpoint.get('videoId') or last_id,
5270                 'index': watch_endpoint.get('index') or len(videos),
5271                 'params': watch_endpoint.get('params') or 'OAE%3D',
5272             }
5273             response = self._extract_response(
5274                 item_id=f'{playlist_id} page {page_num}',
5275                 query=query, ep='next', headers=headers, ytcfg=ytcfg,
5276                 check_get_keys='contents',
5277             )
5278             playlist = try_get(
5279                 response, lambda x: x['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5280
5281     def _extract_from_playlist(self, item_id, url, data, playlist, ytcfg):
5282         title = playlist.get('title') or try_get(
5283             data, lambda x: x['titleText']['simpleText'], str)
5284         playlist_id = playlist.get('playlistId') or item_id
5285
5286         # Delegating everything except mix playlists to regular tab-based playlist URL
5287         playlist_url = urljoin(url, try_get(
5288             playlist, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5289             str))
5290
5291         # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5292         # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5293         is_known_unviewable = re.fullmatch(r'MLCT|RLTD[\w-]{22}', playlist_id)
5294
5295         if playlist_url and playlist_url != url and not is_known_unviewable:
5296             return self.url_result(
5297                 playlist_url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
5298                 video_title=title)
5299
5300         return self.playlist_result(
5301             self._extract_inline_playlist(playlist, playlist_id, data, ytcfg),
5302             playlist_id=playlist_id, playlist_title=title)
5303
5304     def _extract_availability(self, data):
5305         """
5306         Gets the availability of a given playlist/tab.
5307         Note: Unless YouTube tells us explicitly, we do not assume it is public
5308         @param data: response
5309         """
5310         sidebar_renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer') or {}
5311         playlist_header_renderer = traverse_obj(data, ('header', 'playlistHeaderRenderer')) or {}
5312         player_header_privacy = playlist_header_renderer.get('privacy')
5313
5314         badges = self._extract_badges(traverse_obj(sidebar_renderer, 'badges'))
5315
5316         # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5317         privacy_setting_icon = get_first(
5318             (playlist_header_renderer, sidebar_renderer),
5319             ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5320              lambda _, v: v['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5321             expected_type=str)
5322
5323         microformats_is_unlisted = traverse_obj(
5324             data, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type=bool)
5325
5326         return (
5327             'public' if (
5328                 self._has_badge(badges, BadgeType.AVAILABILITY_PUBLIC)
5329                 or player_header_privacy == 'PUBLIC'
5330                 or privacy_setting_icon == 'PRIVACY_PUBLIC')
5331             else self._availability(
5332                 is_private=(
5333                     self._has_badge(badges, BadgeType.AVAILABILITY_PRIVATE)
5334                     or player_header_privacy == 'PRIVATE' if player_header_privacy is not None
5335                     else privacy_setting_icon == 'PRIVACY_PRIVATE' if privacy_setting_icon is not None else None),
5336                 is_unlisted=(
5337                     self._has_badge(badges, BadgeType.AVAILABILITY_UNLISTED)
5338                     or player_header_privacy == 'UNLISTED' if player_header_privacy is not None
5339                     else privacy_setting_icon == 'PRIVACY_UNLISTED' if privacy_setting_icon is not None
5340                     else microformats_is_unlisted if microformats_is_unlisted is not None else None),
5341                 needs_subscription=self._has_badge(badges, BadgeType.AVAILABILITY_SUBSCRIPTION) or None,
5342                 needs_premium=self._has_badge(badges, BadgeType.AVAILABILITY_PREMIUM) or None,
5343                 needs_auth=False))
5344
5345     @staticmethod
5346     def _extract_sidebar_info_renderer(data, info_renderer, expected_type=dict):
5347         sidebar_renderer = try_get(
5348             data, lambda x: x['sidebar']['playlistSidebarRenderer']['items'], list) or []
5349         for item in sidebar_renderer:
5350             renderer = try_get(item, lambda x: x[info_renderer], expected_type)
5351             if renderer:
5352                 return renderer
5353
5354     def _reload_with_unavailable_videos(self, item_id, data, ytcfg):
5355         """
5356         Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5357         """
5358         is_playlist = bool(traverse_obj(
5359             data, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5360         if not is_playlist:
5361             return
5362         headers = self.generate_api_headers(
5363             ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
5364             visitor_data=self._extract_visitor_data(data, ytcfg))
5365         query = {
5366             'params': 'wgYCCAA=',
5367             'browseId': f'VL{item_id}',
5368         }
5369         return self._extract_response(
5370             item_id=item_id, headers=headers, query=query,
5371             check_get_keys='contents', fatal=False, ytcfg=ytcfg,
5372             note='Redownloading playlist API JSON with unavailable videos')
5373
5374     @functools.cached_property
5375     def skip_webpage(self):
5376         return 'webpage' in self._configuration_arg('skip', ie_key=YoutubeTabIE.ie_key())
5377
5378     def _extract_webpage(self, url, item_id, fatal=True):
5379         webpage, data = None, None
5380         for retry in self.RetryManager(fatal=fatal):
5381             try:
5382                 webpage = self._download_webpage(url, item_id, note='Downloading webpage')
5383                 data = self.extract_yt_initial_data(item_id, webpage or '', fatal=fatal) or {}
5384             except ExtractorError as e:
5385                 if isinstance(e.cause, network_exceptions):
5386                     if not isinstance(e.cause, HTTPError) or e.cause.status not in (403, 429):
5387                         retry.error = e
5388                         continue
5389                 self._error_or_warning(e, fatal=fatal)
5390                 break
5391
5392             try:
5393                 self._extract_and_report_alerts(data)
5394             except ExtractorError as e:
5395                 self._error_or_warning(e, fatal=fatal)
5396                 break
5397
5398             # Sometimes youtube returns a webpage with incomplete ytInitialData
5399             # See: https://github.com/yt-dlp/yt-dlp/issues/116
5400             if not traverse_obj(data, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5401                 retry.error = ExtractorError('Incomplete yt initial data received')
5402                 data = None
5403                 continue
5404
5405         return webpage, data
5406
5407     def _report_playlist_authcheck(self, ytcfg, fatal=True):
5408         """Use if failed to extract ytcfg (and data) from initial webpage"""
5409         if not ytcfg and self.is_authenticated:
5410             msg = 'Playlists that require authentication may not extract correctly without a successful webpage download'
5411             if 'authcheck' not in self._configuration_arg('skip', ie_key=YoutubeTabIE.ie_key()) and fatal:
5412                 raise ExtractorError(
5413                     f'{msg}. If you are not downloading private content, or '
5414                     'your cookies are only for the first account and channel,'
5415                     ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5416                     expected=True)
5417             self.report_warning(msg, only_once=True)
5418
5419     def _extract_data(self, url, item_id, ytcfg=None, fatal=True, webpage_fatal=False, default_client='web'):
5420         data = None
5421         if not self.skip_webpage:
5422             webpage, data = self._extract_webpage(url, item_id, fatal=webpage_fatal)
5423             ytcfg = ytcfg or self.extract_ytcfg(item_id, webpage)
5424             # Reject webpage data if redirected to home page without explicitly requesting
5425             selected_tab = self._extract_selected_tab(self._extract_tab_renderers(data), fatal=False) or {}
5426             if (url != 'https://www.youtube.com/feed/recommended'
5427                     and selected_tab.get('tabIdentifier') == 'FEwhat_to_watch'  # Home page
5428                     and 'no-youtube-channel-redirect' not in self.get_param('compat_opts', [])):
5429                 msg = 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5430                 if fatal:
5431                     raise ExtractorError(msg, expected=True)
5432                 self.report_warning(msg, only_once=True)
5433         if not data:
5434             self._report_playlist_authcheck(ytcfg, fatal=fatal)
5435             data = self._extract_tab_endpoint(url, item_id, ytcfg, fatal=fatal, default_client=default_client)
5436         return data, ytcfg
5437
5438     def _extract_tab_endpoint(self, url, item_id, ytcfg=None, fatal=True, default_client='web'):
5439         headers = self.generate_api_headers(ytcfg=ytcfg, default_client=default_client)
5440         resolve_response = self._extract_response(
5441             item_id=item_id, query={'url': url}, check_get_keys='endpoint', headers=headers, ytcfg=ytcfg, fatal=fatal,
5442             ep='navigation/resolve_url', note='Downloading API parameters API JSON', default_client=default_client)
5443         endpoints = {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5444         for ep_key, ep in endpoints.items():
5445             params = try_get(resolve_response, lambda x: x['endpoint'][ep_key], dict)
5446             if params:
5447                 return self._extract_response(
5448                     item_id=item_id, query=params, ep=ep, headers=headers,
5449                     ytcfg=ytcfg, fatal=fatal, default_client=default_client,
5450                     check_get_keys=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5451         err_note = 'Failed to resolve url (does the playlist exist?)'
5452         if fatal:
5453             raise ExtractorError(err_note, expected=True)
5454         self.report_warning(err_note, item_id)
5455
5456     _SEARCH_PARAMS = None
5457
5458     def _search_results(self, query, params=NO_DEFAULT, default_client='web'):
5459         data = {'query': query}
5460         if params is NO_DEFAULT:
5461             params = self._SEARCH_PARAMS
5462         if params:
5463             data['params'] = params
5464
5465         content_keys = (
5466             ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5467             ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5468             # ytmusic search
5469             ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5470             ('continuationContents', ),
5471         )
5472         display_id = f'query "{query}"'
5473         check_get_keys = tuple({keys[0] for keys in content_keys})
5474         ytcfg = self._download_ytcfg(default_client, display_id) if not self.skip_webpage else {}
5475         self._report_playlist_authcheck(ytcfg, fatal=False)
5476
5477         continuation_list = [None]
5478         search = None
5479         for page_num in itertools.count(1):
5480             data.update(continuation_list[0] or {})
5481             headers = self.generate_api_headers(
5482                 ytcfg=ytcfg, visitor_data=self._extract_visitor_data(search), default_client=default_client)
5483             search = self._extract_response(
5484                 item_id=f'{display_id} page {page_num}', ep='search', query=data,
5485                 default_client=default_client, check_get_keys=check_get_keys, ytcfg=ytcfg, headers=headers)
5486             slr_contents = traverse_obj(search, *content_keys)
5487             yield from self._extract_entries({'contents': list(variadic(slr_contents))}, continuation_list)
5488             if not continuation_list[0]:
5489                 break
5490
5491
5492 class YoutubeTabIE(YoutubeTabBaseInfoExtractor):
5493     IE_DESC = 'YouTube Tabs'
5494     _VALID_URL = r'''(?x:
5495         https?://
5496             (?!consent\.)(?:\w+\.)?
5497             (?:
5498                 youtube(?:kids)?\.com|
5499                 {invidious}
5500             )/
5501             (?:
5502                 (?P<channel_type>channel|c|user|browse)/|
5503                 (?P<not_channel>
5504                     feed/|hashtag/|
5505                     (?:playlist|watch)\?.*?\blist=
5506                 )|
5507                 (?!(?:{reserved_names})\b)  # Direct URLs
5508             )
5509             (?P<id>[^/?\#&]+)
5510     )'''.format(
5511         reserved_names=YoutubeBaseInfoExtractor._RESERVED_NAMES,
5512         invidious='|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
5513     )
5514     IE_NAME = 'youtube:tab'
5515
5516     _TESTS = [{
5517         'note': 'playlists, multipage',
5518         'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5519         'playlist_mincount': 94,
5520         'info_dict': {
5521             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5522             'title': 'Igor Kleiner Ph.D. - Playlists',
5523             'description': 'md5:15d7dd9e333cb987907fcb0d604b233a',
5524             'uploader': 'Igor Kleiner Ph.D.',
5525             'uploader_id': '@IgorDataScience',
5526             'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5527             'channel': 'Igor Kleiner Ph.D.',
5528             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5529             'tags': ['критическое мышление', 'наука просто', 'математика', 'анализ данных'],
5530             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5531             'channel_follower_count': int,
5532         },
5533     }, {
5534         'note': 'playlists, multipage, different order',
5535         'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5536         'playlist_mincount': 94,
5537         'info_dict': {
5538             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5539             'title': 'Igor Kleiner Ph.D. - Playlists',
5540             'description': 'md5:15d7dd9e333cb987907fcb0d604b233a',
5541             'uploader': 'Igor Kleiner Ph.D.',
5542             'uploader_id': '@IgorDataScience',
5543             'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5544             'tags': ['критическое мышление', 'наука просто', 'математика', 'анализ данных'],
5545             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5546             'channel': 'Igor Kleiner Ph.D.',
5547             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5548             'channel_follower_count': int,
5549         },
5550     }, {
5551         'note': 'playlists, series',
5552         'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5553         'playlist_mincount': 5,
5554         'info_dict': {
5555             'id': 'UCYO_jab_esuFRV4b17AJtAw',
5556             'title': '3Blue1Brown - Playlists',
5557             'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
5558             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5559             'channel': '3Blue1Brown',
5560             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5561             'uploader_id': '@3blue1brown',
5562             'uploader_url': 'https://www.youtube.com/@3blue1brown',
5563             'uploader': '3Blue1Brown',
5564             'tags': ['Mathematics'],
5565             'channel_follower_count': int,
5566             'channel_is_verified': True,
5567         },
5568     }, {
5569         'note': 'playlists, singlepage',
5570         'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5571         'playlist_mincount': 4,
5572         'info_dict': {
5573             'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5574             'title': 'ThirstForScience - Playlists',
5575             'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5576             'uploader': 'ThirstForScience',
5577             'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5578             'uploader_id': '@ThirstForScience',
5579             'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5580             'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5581             'tags': 'count:12',
5582             'channel': 'ThirstForScience',
5583             'channel_follower_count': int,
5584         },
5585     }, {
5586         'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5587         'only_matching': True,
5588     }, {
5589         'note': 'basic, single video playlist',
5590         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5591         'info_dict': {
5592             'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5593             'title': 'youtube-dl public playlist',
5594             'description': '',
5595             'tags': [],
5596             'view_count': int,
5597             'modified_date': '20201130',
5598             'channel': 'Sergey M.',
5599             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5600             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5601             'availability': 'public',
5602             'uploader': 'Sergey M.',
5603             'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5604             'uploader_id': '@sergeym.6173',
5605         },
5606         'playlist_count': 1,
5607     }, {
5608         'note': 'empty playlist',
5609         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5610         'info_dict': {
5611             'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5612             'title': 'youtube-dl empty playlist',
5613             'tags': [],
5614             'channel': 'Sergey M.',
5615             'description': '',
5616             'modified_date': '20230921',
5617             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5618             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5619             'availability': 'unlisted',
5620             'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5621             'uploader_id': '@sergeym.6173',
5622             'uploader': 'Sergey M.',
5623         },
5624         'playlist_count': 0,
5625     }, {
5626         'note': 'Home tab',
5627         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5628         'info_dict': {
5629             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5630             'title': 'lex will - Home',
5631             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5632             'uploader': 'lex will',
5633             'uploader_id': '@lexwill718',
5634             'channel': 'lex will',
5635             'tags': ['bible', 'history', 'prophesy'],
5636             'uploader_url': 'https://www.youtube.com/@lexwill718',
5637             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5638             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5639             'channel_follower_count': int,
5640         },
5641         'playlist_mincount': 2,
5642     }, {
5643         'note': 'Videos tab',
5644         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5645         'info_dict': {
5646             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5647             'title': 'lex will - Videos',
5648             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5649             'uploader': 'lex will',
5650             'uploader_id': '@lexwill718',
5651             'tags': ['bible', 'history', 'prophesy'],
5652             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5653             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5654             'uploader_url': 'https://www.youtube.com/@lexwill718',
5655             'channel': 'lex will',
5656             'channel_follower_count': int,
5657         },
5658         'playlist_mincount': 975,
5659     }, {
5660         'note': 'Videos tab, sorted by popular',
5661         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5662         'info_dict': {
5663             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5664             'title': 'lex will - Videos',
5665             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5666             'uploader': 'lex will',
5667             'uploader_id': '@lexwill718',
5668             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5669             'uploader_url': 'https://www.youtube.com/@lexwill718',
5670             'channel': 'lex will',
5671             'tags': ['bible', 'history', 'prophesy'],
5672             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5673             'channel_follower_count': int,
5674         },
5675         'playlist_mincount': 199,
5676     }, {
5677         'note': 'Playlists tab',
5678         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5679         'info_dict': {
5680             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5681             'title': 'lex will - Playlists',
5682             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5683             'uploader': 'lex will',
5684             'uploader_id': '@lexwill718',
5685             'uploader_url': 'https://www.youtube.com/@lexwill718',
5686             'channel': 'lex will',
5687             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5688             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5689             'tags': ['bible', 'history', 'prophesy'],
5690             'channel_follower_count': int,
5691         },
5692         'playlist_mincount': 17,
5693     }, {
5694         'note': 'Community tab',
5695         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5696         'info_dict': {
5697             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5698             'title': 'lex will - Community',
5699             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5700             'channel': 'lex will',
5701             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5702             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5703             'tags': ['bible', 'history', 'prophesy'],
5704             'channel_follower_count': int,
5705             'uploader_url': 'https://www.youtube.com/@lexwill718',
5706             'uploader_id': '@lexwill718',
5707             'uploader': 'lex will',
5708         },
5709         'playlist_mincount': 18,
5710     }, {
5711         'note': 'Channels tab',
5712         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5713         'info_dict': {
5714             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5715             'title': 'lex will - Channels',
5716             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5717             'channel': 'lex will',
5718             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5719             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5720             'tags': ['bible', 'history', 'prophesy'],
5721             'channel_follower_count': int,
5722             'uploader_url': 'https://www.youtube.com/@lexwill718',
5723             'uploader_id': '@lexwill718',
5724             'uploader': 'lex will',
5725         },
5726         'playlist_mincount': 12,
5727     }, {
5728         'note': 'Search tab',
5729         'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5730         'playlist_mincount': 40,
5731         'info_dict': {
5732             'id': 'UCYO_jab_esuFRV4b17AJtAw',
5733             'title': '3Blue1Brown - Search - linear algebra',
5734             'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
5735             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5736             'tags': ['Mathematics'],
5737             'channel': '3Blue1Brown',
5738             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5739             'channel_follower_count': int,
5740             'uploader_url': 'https://www.youtube.com/@3blue1brown',
5741             'uploader_id': '@3blue1brown',
5742             'uploader': '3Blue1Brown',
5743             'channel_is_verified': True,
5744         },
5745     }, {
5746         'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5747         'only_matching': True,
5748     }, {
5749         'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5750         'only_matching': True,
5751     }, {
5752         'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5753         'only_matching': True,
5754     }, {
5755         'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5756         'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5757         'info_dict': {
5758             'title': '29C3: Not my department',
5759             'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5760             'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5761             'tags': [],
5762             'view_count': int,
5763             'modified_date': '20150605',
5764             'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5765             'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5766             'channel': 'Christiaan008',
5767             'availability': 'public',
5768             'uploader_id': '@ChRiStIaAn008',
5769             'uploader': 'Christiaan008',
5770             'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5771         },
5772         'playlist_count': 96,
5773     }, {
5774         'note': 'Large playlist',
5775         'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5776         'info_dict': {
5777             'title': 'Uploads from Cauchemar',
5778             'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5779             'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5780             'tags': [],
5781             'modified_date': r're:\d{8}',
5782             'channel': 'Cauchemar',
5783             'view_count': int,
5784             'description': '',
5785             'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5786             'availability': 'public',
5787             'uploader_id': '@Cauchemar89',
5788             'uploader': 'Cauchemar',
5789             'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5790         },
5791         'playlist_mincount': 1123,
5792         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5793     }, {
5794         'note': 'even larger playlist, 8832 videos',
5795         'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5796         'only_matching': True,
5797     }, {
5798         'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5799         'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5800         'info_dict': {
5801             'title': 'Uploads from Interstellar Movie',
5802             'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5803             'tags': [],
5804             'view_count': int,
5805             'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5806             'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5807             'channel': 'Interstellar Movie',
5808             'description': '',
5809             'modified_date': r're:\d{8}',
5810             'availability': 'public',
5811             'uploader_id': '@InterstellarMovie',
5812             'uploader': 'Interstellar Movie',
5813             'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5814         },
5815         'playlist_mincount': 21,
5816     }, {
5817         'note': 'Playlist with "show unavailable videos" button',
5818         'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5819         'info_dict': {
5820             'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5821             'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5822             'view_count': int,
5823             'channel': 'Phim Siêu Nhân Nhật Bản',
5824             'tags': [],
5825             'description': '',
5826             'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5827             'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5828             'modified_date': r're:\d{8}',
5829             'availability': 'public',
5830             'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5831             'uploader_id': '@phimsieunhannhatban',
5832             'uploader': 'Phim Siêu Nhân Nhật Bản',
5833         },
5834         'playlist_mincount': 200,
5835         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5836     }, {
5837         'note': 'Playlist with unavailable videos in page 7',
5838         'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5839         'info_dict': {
5840             'title': 'Uploads from BlankTV',
5841             'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5842             'channel': 'BlankTV',
5843             'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5844             'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5845             'view_count': int,
5846             'tags': [],
5847             'modified_date': r're:\d{8}',
5848             'description': '',
5849             'availability': 'public',
5850             'uploader_id': '@blanktv',
5851             'uploader': 'BlankTV',
5852             'uploader_url': 'https://www.youtube.com/@blanktv',
5853         },
5854         'playlist_mincount': 1000,
5855         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5856     }, {
5857         'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5858         'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5859         'info_dict': {
5860             'title': 'Data Analysis with Dr Mike Pound',
5861             'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5862             'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5863             'tags': [],
5864             'view_count': int,
5865             'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5866             'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5867             'channel': 'Computerphile',
5868             'availability': 'public',
5869             'modified_date': '20190712',
5870             'uploader_id': '@Computerphile',
5871             'uploader': 'Computerphile',
5872             'uploader_url': 'https://www.youtube.com/@Computerphile',
5873         },
5874         'playlist_mincount': 11,
5875     }, {
5876         'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5877         'only_matching': True,
5878     }, {
5879         'note': 'Playlist URL that does not actually serve a playlist',
5880         'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5881         'info_dict': {
5882             'id': 'FqZTN594JQw',
5883             'ext': 'webm',
5884             'title': "Smiley's People 01 detective, Adventure Series, Action",
5885             'upload_date': '20150526',
5886             'license': 'Standard YouTube License',
5887             'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5888             'categories': ['People & Blogs'],
5889             'tags': list,
5890             'view_count': int,
5891             'like_count': int,
5892         },
5893         'params': {
5894             'skip_download': True,
5895         },
5896         'skip': 'This video is not available.',
5897         'add_ie': [YoutubeIE.ie_key()],
5898     }, {
5899         'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5900         'only_matching': True,
5901     }, {
5902         'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5903         'only_matching': True,
5904     }, {
5905         'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5906         'info_dict': {
5907             'id': 'hGkQjiJLjWQ',  # This will keep changing
5908             'ext': 'mp4',
5909             'title': str,
5910             'upload_date': r're:\d{8}',
5911             'description': str,
5912             'categories': ['News & Politics'],
5913             'tags': list,
5914             'like_count': int,
5915             'release_timestamp': int,
5916             'channel': 'Sky News',
5917             'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5918             'age_limit': 0,
5919             'view_count': int,
5920             'thumbnail': r're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5921             'playable_in_embed': True,
5922             'release_date': r're:\d+',
5923             'availability': 'public',
5924             'live_status': 'is_live',
5925             'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5926             'channel_follower_count': int,
5927             'concurrent_view_count': int,
5928             'uploader_url': 'https://www.youtube.com/@SkyNews',
5929             'uploader_id': '@SkyNews',
5930             'uploader': 'Sky News',
5931             'channel_is_verified': True,
5932         },
5933         'params': {
5934             'skip_download': True,
5935         },
5936         'expected_warnings': ['Ignoring subtitle tracks found in '],
5937     }, {
5938         'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5939         'info_dict': {
5940             'id': 'a48o2S1cPoo',
5941             'ext': 'mp4',
5942             'title': 'The Young Turks - Live Main Show',
5943             'upload_date': '20150715',
5944             'license': 'Standard YouTube License',
5945             'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5946             'categories': ['News & Politics'],
5947             'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5948             'like_count': int,
5949         },
5950         'params': {
5951             'skip_download': True,
5952         },
5953         'only_matching': True,
5954     }, {
5955         'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5956         'only_matching': True,
5957     }, {
5958         'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5959         'only_matching': True,
5960     }, {
5961         'note': 'A channel that is not live. Should raise error',
5962         'url': 'https://www.youtube.com/user/numberphile/live',
5963         'only_matching': True,
5964     }, {
5965         'url': 'https://www.youtube.com/feed/trending',
5966         'only_matching': True,
5967     }, {
5968         'url': 'https://www.youtube.com/feed/library',
5969         'only_matching': True,
5970     }, {
5971         'url': 'https://www.youtube.com/feed/history',
5972         'only_matching': True,
5973     }, {
5974         'url': 'https://www.youtube.com/feed/subscriptions',
5975         'only_matching': True,
5976     }, {
5977         'url': 'https://www.youtube.com/feed/watch_later',
5978         'only_matching': True,
5979     }, {
5980         'note': 'Recommended - redirects to home page.',
5981         'url': 'https://www.youtube.com/feed/recommended',
5982         'only_matching': True,
5983     }, {
5984         'note': 'inline playlist with not always working continuations',
5985         'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5986         'only_matching': True,
5987     }, {
5988         'url': 'https://www.youtube.com/course',
5989         'only_matching': True,
5990     }, {
5991         'url': 'https://www.youtube.com/zsecurity',
5992         'only_matching': True,
5993     }, {
5994         'url': 'http://www.youtube.com/NASAgovVideo/videos',
5995         'only_matching': True,
5996     }, {
5997         'url': 'https://www.youtube.com/TheYoungTurks/live',
5998         'only_matching': True,
5999     }, {
6000         'url': 'https://www.youtube.com/hashtag/cctv9',
6001         'info_dict': {
6002             'id': 'cctv9',
6003             'title': 'cctv9 - All',
6004             'tags': [],
6005         },
6006         'playlist_mincount': 300,  # not consistent but should be over 300
6007     }, {
6008         'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
6009         'only_matching': True,
6010     }, {
6011         'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
6012         'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6013         'only_matching': True,
6014     }, {
6015         'note': '/browse/ should redirect to /channel/',
6016         'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
6017         'only_matching': True,
6018     }, {
6019         'note': 'VLPL, should redirect to playlist?list=PL...',
6020         'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6021         'info_dict': {
6022             'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6023             'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
6024             'title': 'NCS : All Releases 💿',
6025             'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
6026             'modified_date': r're:\d{8}',
6027             'view_count': int,
6028             'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
6029             'tags': [],
6030             'channel': 'NoCopyrightSounds',
6031             'availability': 'public',
6032             'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
6033             'uploader': 'NoCopyrightSounds',
6034             'uploader_id': '@NoCopyrightSounds',
6035         },
6036         'playlist_mincount': 166,
6037         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
6038     }, {
6039         # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
6040         'note': 'Topic, should redirect to playlist?list=UU...',
6041         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6042         'info_dict': {
6043             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6044             'title': 'Uploads from Royalty Free Music - Topic',
6045             'tags': [],
6046             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6047             'channel': 'Royalty Free Music - Topic',
6048             'view_count': int,
6049             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6050             'modified_date': r're:\d{8}',
6051             'description': '',
6052             'availability': 'public',
6053             'uploader': 'Royalty Free Music - Topic',
6054         },
6055         'playlist_mincount': 101,
6056         'expected_warnings': ['YouTube Music is not directly supported', r'[Uu]navailable videos (are|will be) hidden'],
6057     }, {
6058         # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
6059         # Treat as a general feed
6060         'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
6061         'info_dict': {
6062             'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
6063             'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
6064             'tags': [],
6065         },
6066         'playlist_mincount': 9,
6067     }, {
6068         'note': 'Youtube music Album',
6069         'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
6070         'info_dict': {
6071             'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
6072             'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
6073             'tags': [],
6074             'view_count': int,
6075             'description': '',
6076             'availability': 'unlisted',
6077             'modified_date': r're:\d{8}',
6078         },
6079         'playlist_count': 50,
6080         'expected_warnings': ['YouTube Music is not directly supported'],
6081     }, {
6082         'note': 'unlisted single video playlist',
6083         'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
6084         'info_dict': {
6085             'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
6086             'title': 'yt-dlp unlisted playlist test',
6087             'availability': 'unlisted',
6088             'tags': [],
6089             'modified_date': '20220418',
6090             'channel': 'colethedj',
6091             'view_count': int,
6092             'description': '',
6093             'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
6094             'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
6095             'uploader_url': 'https://www.youtube.com/@colethedj1894',
6096             'uploader_id': '@colethedj1894',
6097             'uploader': 'colethedj',
6098         },
6099         'playlist': [{
6100             'info_dict': {
6101                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
6102                 'id': 'BaW_jenozKc',
6103                 '_type': 'url',
6104                 'ie_key': 'Youtube',
6105                 'duration': 10,
6106                 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
6107                 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
6108                 'view_count': int,
6109                 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
6110                 'channel': 'Philipp Hagemeister',
6111                 'uploader_id': '@PhilippHagemeister',
6112                 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6113                 'uploader': 'Philipp Hagemeister',
6114             },
6115         }],
6116         'playlist_count': 1,
6117         'params': {'extract_flat': True},
6118     }, {
6119         'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6120         'url': 'https://www.youtube.com/feed/recommended',
6121         'info_dict': {
6122             'id': 'recommended',
6123             'title': 'recommended',
6124             'tags': [],
6125         },
6126         'playlist_mincount': 50,
6127         'params': {
6128             'skip_download': True,
6129             'extractor_args': {'youtubetab': {'skip': ['webpage']}},
6130         },
6131     }, {
6132         'note': 'API Fallback: /videos tab, sorted by oldest first',
6133         'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6134         'info_dict': {
6135             'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6136             'title': 'Cody\'sLab - Videos',
6137             'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6138             'channel': 'Cody\'sLab',
6139             'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6140             'tags': [],
6141             'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6142             'channel_follower_count': int,
6143         },
6144         'playlist_mincount': 650,
6145         'params': {
6146             'skip_download': True,
6147             'extractor_args': {'youtubetab': {'skip': ['webpage']}},
6148         },
6149         'skip': 'Query for sorting no longer works',
6150     }, {
6151         'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6152         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6153         'info_dict': {
6154             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6155             'title': 'Uploads from Royalty Free Music - Topic',
6156             'modified_date': r're:\d{8}',
6157             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6158             'description': '',
6159             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6160             'tags': [],
6161             'channel': 'Royalty Free Music - Topic',
6162             'view_count': int,
6163             'availability': 'public',
6164             'uploader': 'Royalty Free Music - Topic',
6165         },
6166         'playlist_mincount': 101,
6167         'params': {
6168             'skip_download': True,
6169             'extractor_args': {'youtubetab': {'skip': ['webpage']}},
6170         },
6171         'expected_warnings': ['YouTube Music is not directly supported', r'[Uu]navailable videos (are|will be) hidden'],
6172     }, {
6173         'note': 'non-standard redirect to regional channel',
6174         'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6175         'only_matching': True,
6176     }, {
6177         'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6178         'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6179         'info_dict': {
6180             'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6181             'modified_date': '20220407',
6182             'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6183             'tags': [],
6184             'availability': 'unlisted',
6185             'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6186             'channel': 'pukkandan',
6187             'description': 'Test for collaborative playlist',
6188             'title': 'yt-dlp test - collaborative playlist',
6189             'view_count': int,
6190             'uploader_url': 'https://www.youtube.com/@pukkandan',
6191             'uploader_id': '@pukkandan',
6192             'uploader': 'pukkandan',
6193         },
6194         'playlist_mincount': 2,
6195     }, {
6196         'note': 'translated tab name',
6197         'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6198         'info_dict': {
6199             'id': 'UCiu-3thuViMebBjw_5nWYrA',
6200             'tags': [],
6201             'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6202             'description': 'test description',
6203             'title': 'cole-dlp-test-acc - 再生リスト',
6204             'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6205             'channel': 'cole-dlp-test-acc',
6206             'uploader_url': 'https://www.youtube.com/@coletdjnz',
6207             'uploader_id': '@coletdjnz',
6208             'uploader': 'cole-dlp-test-acc',
6209         },
6210         'playlist_mincount': 1,
6211         'params': {'extractor_args': {'youtube': {'lang': ['ja']}}},
6212         'expected_warnings': ['Preferring "ja"'],
6213     }, {
6214         # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6215         'note': 'preferred lang set with playlist with translated video titles',
6216         'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6217         'info_dict': {
6218             'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6219             'tags': [],
6220             'view_count': int,
6221             'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6222             'channel': 'cole-dlp-test-acc',
6223             'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6224             'description': 'test',
6225             'title': 'dlp test playlist',
6226             'availability': 'public',
6227             'uploader_url': 'https://www.youtube.com/@coletdjnz',
6228             'uploader_id': '@coletdjnz',
6229             'uploader': 'cole-dlp-test-acc',
6230         },
6231         'playlist_mincount': 1,
6232         'params': {'extractor_args': {'youtube': {'lang': ['ja']}}},
6233         'expected_warnings': ['Preferring "ja"'],
6234     }, {
6235         # shorts audio pivot for 2GtVksBMYFM.
6236         'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6237         'info_dict': {
6238             'id': 'sfv_audio_pivot',
6239             'title': 'sfv_audio_pivot',
6240             'tags': [],
6241         },
6242         'playlist_mincount': 50,
6243
6244     }, {
6245         # Channel with a real live tab (not to be mistaken with streams tab)
6246         # Do not treat like it should redirect to live stream
6247         'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6248         'info_dict': {
6249             'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6250             'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6251             'tags': [],
6252         },
6253         'playlist_mincount': 20,
6254     }, {
6255         # Tab name is not the same as tab id
6256         'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6257         'info_dict': {
6258             'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6259             'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6260             'tags': [],
6261         },
6262         'playlist_mincount': 8,
6263     }, {
6264         # Home tab id is literally home. Not to get mistaken with featured
6265         'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6266         'info_dict': {
6267             'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6268             'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6269             'tags': [],
6270         },
6271         'playlist_mincount': 8,
6272     }, {
6273         # Should get three playlists for videos, shorts and streams tabs
6274         'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6275         'info_dict': {
6276             'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6277             'title': 'Polka Ch. 尾丸ポルカ',
6278             'channel_follower_count': int,
6279             'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6280             'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6281             'description': 'md5:49809d8bf9da539bc48ed5d1f83c33f2',
6282             'channel': 'Polka Ch. 尾丸ポルカ',
6283             'tags': 'count:35',
6284             'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6285             'uploader': 'Polka Ch. 尾丸ポルカ',
6286             'uploader_id': '@OmaruPolka',
6287             'channel_is_verified': True,
6288         },
6289         'playlist_count': 3,
6290     }, {
6291         # Shorts tab with channel with handle
6292         # TODO: fix channel description
6293         'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6294         'info_dict': {
6295             'id': 'UC0intLFzLaudFG-xAvUEO-A',
6296             'title': 'Not Just Bikes - Shorts',
6297             'tags': 'count:10',
6298             'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6299             'description': 'md5:5e82545b3a041345927a92d0585df247',
6300             'channel_follower_count': int,
6301             'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6302             'channel': 'Not Just Bikes',
6303             'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6304             'uploader': 'Not Just Bikes',
6305             'uploader_id': '@NotJustBikes',
6306             'channel_is_verified': True,
6307         },
6308         'playlist_mincount': 10,
6309     }, {
6310         # Streams tab
6311         'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6312         'info_dict': {
6313             'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6314             'title': '中村悠一 - Live',
6315             'tags': 'count:7',
6316             'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6317             'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6318             'channel': '中村悠一',
6319             'channel_follower_count': int,
6320             'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6321             'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6322             'uploader_id': '@Yuichi-Nakamura',
6323             'uploader': '中村悠一',
6324         },
6325         'playlist_mincount': 60,
6326     }, {
6327         # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6328         # See test_youtube_lists
6329         'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6330         'only_matching': True,
6331     }, {
6332         # No uploads and no UCID given. Should fail with no uploads error
6333         # See test_youtube_lists
6334         'url': 'https://www.youtube.com/news',
6335         'only_matching': True,
6336     }, {
6337         # No videos tab but has a shorts tab
6338         'url': 'https://www.youtube.com/c/TKFShorts',
6339         'info_dict': {
6340             'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6341             'title': 'Shorts Break - Shorts',
6342             'tags': 'count:48',
6343             'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6344             'channel': 'Shorts Break',
6345             'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6346             'channel_follower_count': int,
6347             'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6348             'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6349             'uploader': 'Shorts Break',
6350             'uploader_id': '@ShortsBreak_Official',
6351         },
6352         'playlist_mincount': 30,
6353     }, {
6354         # Trending Now Tab. tab id is empty
6355         'url': 'https://www.youtube.com/feed/trending',
6356         'info_dict': {
6357             'id': 'trending',
6358             'title': 'trending - Now',
6359             'tags': [],
6360         },
6361         'playlist_mincount': 30,
6362     }, {
6363         # Trending Gaming Tab. tab id is empty
6364         'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6365         'info_dict': {
6366             'id': 'trending',
6367             'title': 'trending - Gaming',
6368             'tags': [],
6369         },
6370         'playlist_mincount': 30,
6371     }, {
6372         # Shorts url result in shorts tab
6373         # TODO: Fix channel id extraction
6374         'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6375         'info_dict': {
6376             'id': 'UCiu-3thuViMebBjw_5nWYrA',
6377             'title': 'cole-dlp-test-acc - Shorts',
6378             'channel': 'cole-dlp-test-acc',
6379             'description': 'test description',
6380             'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6381             'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6382             'tags': [],
6383             'uploader_url': 'https://www.youtube.com/@coletdjnz',
6384             'uploader_id': '@coletdjnz',
6385             'uploader': 'cole-dlp-test-acc',
6386         },
6387         'playlist': [{
6388             'info_dict': {
6389                 # Channel data is not currently available for short renderers (as of 2023-03-01)
6390                 '_type': 'url',
6391                 'ie_key': 'Youtube',
6392                 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6393                 'id': 'sSM9J5YH_60',
6394                 'title': 'SHORT short',
6395                 'view_count': int,
6396                 'thumbnails': list,
6397             },
6398         }],
6399         'params': {'extract_flat': True},
6400     }, {
6401         # Live video status should be extracted
6402         'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6403         'info_dict': {
6404             'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6405             'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live',  # TODO: should be Minecraft - Live or Minecraft - Topic - Live
6406             'tags': [],
6407         },
6408         'playlist': [{
6409             'info_dict': {
6410                 '_type': 'url',
6411                 'ie_key': 'Youtube',
6412                 'url': 'startswith:https://www.youtube.com/watch?v=',
6413                 'id': str,
6414                 'title': str,
6415                 'live_status': 'is_live',
6416                 'channel_id': str,
6417                 'channel_url': str,
6418                 'concurrent_view_count': int,
6419                 'channel': str,
6420                 'uploader': str,
6421                 'uploader_url': str,
6422                 'uploader_id': str,
6423                 'channel_is_verified': bool,  # this will keep changing
6424             },
6425         }],
6426         'params': {'extract_flat': True, 'playlist_items': '1'},
6427         'playlist_mincount': 1,
6428     }, {
6429         # Channel renderer metadata. Contains number of videos on the channel
6430         'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6431         'info_dict': {
6432             'id': 'UCiu-3thuViMebBjw_5nWYrA',
6433             'title': 'cole-dlp-test-acc - Channels',
6434             'channel': 'cole-dlp-test-acc',
6435             'description': 'test description',
6436             'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6437             'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6438             'tags': [],
6439             'uploader_url': 'https://www.youtube.com/@coletdjnz',
6440             'uploader_id': '@coletdjnz',
6441             'uploader': 'cole-dlp-test-acc',
6442         },
6443         'playlist': [{
6444             'info_dict': {
6445                 '_type': 'url',
6446                 'ie_key': 'YoutubeTab',
6447                 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6448                 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6449                 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6450                 'title': 'PewDiePie',
6451                 'channel': 'PewDiePie',
6452                 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6453                 'thumbnails': list,
6454                 'channel_follower_count': int,
6455                 'playlist_count': int,
6456                 'uploader': 'PewDiePie',
6457                 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6458                 'uploader_id': '@PewDiePie',
6459                 'channel_is_verified': True,
6460             },
6461         }],
6462         'params': {'extract_flat': True},
6463     }, {
6464         'url': 'https://www.youtube.com/@3blue1brown/about',
6465         'info_dict': {
6466             'id': '@3blue1brown',
6467             'tags': ['Mathematics'],
6468             'title': '3Blue1Brown',
6469             'channel_follower_count': int,
6470             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6471             'channel': '3Blue1Brown',
6472             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6473             'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
6474             'uploader_url': 'https://www.youtube.com/@3blue1brown',
6475             'uploader_id': '@3blue1brown',
6476             'uploader': '3Blue1Brown',
6477             'channel_is_verified': True,
6478         },
6479         'playlist_count': 0,
6480     }, {
6481         # Podcasts tab, with rich entry playlistRenderers
6482         'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6483         'info_dict': {
6484             'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6485             'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6486             'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6487             'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6488             'title': '99 Percent Invisible - Podcasts',
6489             'uploader': '99 Percent Invisible',
6490             'channel_follower_count': int,
6491             'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6492             'tags': [],
6493             'channel': '99 Percent Invisible',
6494             'uploader_id': '@99percentinvisiblepodcast',
6495         },
6496         'playlist_count': 0,
6497     }, {
6498         # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6499         'url': 'https://www.youtube.com/@AHimitsu/releases',
6500         'info_dict': {
6501             'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6502             'channel': 'A Himitsu',
6503             'uploader_url': 'https://www.youtube.com/@AHimitsu',
6504             'title': 'A Himitsu - Releases',
6505             'uploader_id': '@AHimitsu',
6506             'uploader': 'A Himitsu',
6507             'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6508             'tags': 'count:12',
6509             'description': 'I make music',
6510             'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6511             'channel_follower_count': int,
6512             'channel_is_verified': True,
6513         },
6514         'playlist_mincount': 10,
6515     }, {
6516         # Playlist with only shorts, shown as reel renderers
6517         # FIXME: future: YouTube currently doesn't give continuation for this,
6518         # may do in future.
6519         'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6520         'info_dict': {
6521             'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6522             'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6523             'view_count': int,
6524             'uploader_id': '@BangyShorts',
6525             'description': '',
6526             'uploader_url': 'https://www.youtube.com/@BangyShorts',
6527             'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6528             'channel': 'Bangy Shorts',
6529             'uploader': 'Bangy Shorts',
6530             'tags': [],
6531             'availability': 'public',
6532             'modified_date': r're:\d{8}',
6533             'title': 'Uploads from Bangy Shorts',
6534         },
6535         'playlist_mincount': 100,
6536         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
6537     }, {
6538         'note': 'Tags containing spaces',
6539         'url': 'https://www.youtube.com/channel/UC7_YxT-KID8kRbqZo7MyscQ',
6540         'playlist_count': 3,
6541         'info_dict': {
6542             'id': 'UC7_YxT-KID8kRbqZo7MyscQ',
6543             'channel': 'Markiplier',
6544             'channel_id': 'UC7_YxT-KID8kRbqZo7MyscQ',
6545             'title': 'Markiplier',
6546             'channel_follower_count': int,
6547             'description': 'md5:0c010910558658824402809750dc5d97',
6548             'uploader_id': '@markiplier',
6549             'uploader_url': 'https://www.youtube.com/@markiplier',
6550             'uploader': 'Markiplier',
6551             'channel_url': 'https://www.youtube.com/channel/UC7_YxT-KID8kRbqZo7MyscQ',
6552             'channel_is_verified': True,
6553             'tags': ['markiplier', 'comedy', 'gaming', 'funny videos', 'funny moments',
6554                      'sketch comedy', 'laughing', 'lets play', 'challenge videos', 'hilarious',
6555                      'challenges', 'sketches', 'scary games', 'funny games', 'rage games',
6556                      'mark fischbach'],
6557         },
6558     }]
6559
6560     @classmethod
6561     def suitable(cls, url):
6562         return False if YoutubeIE.suitable(url) else super().suitable(url)
6563
6564     _URL_RE = re.compile(rf'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6565
6566     def _get_url_mobj(self, url):
6567         mobj = self._URL_RE.match(url).groupdict()
6568         mobj.update((k, '') for k, v in mobj.items() if v is None)
6569         return mobj
6570
6571     def _extract_tab_id_and_name(self, tab, base_url='https://www.youtube.com'):
6572         tab_name = (tab.get('title') or '').lower()
6573         tab_url = urljoin(base_url, traverse_obj(
6574             tab, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6575
6576         tab_id = (tab_url and self._get_url_mobj(tab_url)['tab'][1:]
6577                   or traverse_obj(tab, 'tabIdentifier', expected_type=str))
6578         if tab_id:
6579             return {
6580                 'TAB_ID_SPONSORSHIPS': 'membership',
6581             }.get(tab_id, tab_id), tab_name
6582
6583         # Fallback to tab name if we cannot get the tab id.
6584         # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6585         # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6586         if tab_name:
6587             self.write_debug(f'Falling back to selected tab name: {tab_name}')
6588         return {
6589             'home': 'featured',
6590             'live': 'streams',
6591         }.get(tab_name, tab_name), tab_name
6592
6593     def _has_tab(self, tabs, tab_id):
6594         return any(self._extract_tab_id_and_name(tab)[0] == tab_id for tab in tabs)
6595
6596     def _empty_playlist(self, item_id, data):
6597         return self.playlist_result([], item_id, **self._extract_metadata_from_tabs(item_id, data))
6598
6599     @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6600     def _real_extract(self, url, smuggled_data):
6601         item_id = self._match_id(url)
6602         url = urllib.parse.urlunparse(
6603             urllib.parse.urlparse(url)._replace(netloc='www.youtube.com'))
6604         compat_opts = self.get_param('compat_opts', [])
6605
6606         mobj = self._get_url_mobj(url)
6607         pre, tab, post, is_channel = mobj['pre'], mobj['tab'], mobj['post'], not mobj['not_channel']
6608         if is_channel and smuggled_data.get('is_music_url'):
6609             if item_id[:2] == 'VL':  # Youtube music VL channels have an equivalent playlist
6610                 return self.url_result(
6611                     f'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE, item_id[2:])
6612             elif item_id[:2] == 'MP':  # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6613                 mdata = self._extract_tab_endpoint(
6614                     f'https://music.youtube.com/channel/{item_id}', item_id, default_client='web_music')
6615                 murl = traverse_obj(mdata, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6616                                     get_all=False, expected_type=str)
6617                 if not murl:
6618                     raise ExtractorError('Failed to resolve album to playlist')
6619                 return self.url_result(murl, YoutubeTabIE)
6620             elif mobj['channel_type'] == 'browse':  # Youtube music /browse/ should be changed to /channel/
6621                 return self.url_result(
6622                     f'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE, item_id)
6623
6624         original_tab_id, display_id = tab[1:], f'{item_id}{tab}'
6625         if is_channel and not tab and 'no-youtube-channel-redirect' not in compat_opts:
6626             url = f'{pre}/videos{post}'
6627         if smuggled_data.get('is_music_url'):
6628             self.report_warning(f'YouTube Music is not directly supported. Redirecting to {url}')
6629
6630         # Handle both video/playlist URLs
6631         qs = parse_qs(url)
6632         video_id, playlist_id = (traverse_obj(qs, (key, 0)) for key in ('v', 'list'))
6633         if not video_id and mobj['not_channel'].startswith('watch'):
6634             if not playlist_id:
6635                 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6636                 raise ExtractorError('A video URL was given without video ID', expected=True)
6637             # Common mistake: https://www.youtube.com/watch?list=playlist_id
6638             self.report_warning(f'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6639             return self.url_result(
6640                 f'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE, playlist_id)
6641
6642         if not self._yes_playlist(playlist_id, video_id):
6643             return self.url_result(
6644                 f'https://www.youtube.com/watch?v={video_id}', YoutubeIE, video_id)
6645
6646         data, ytcfg = self._extract_data(url, display_id)
6647
6648         # YouTube may provide a non-standard redirect to the regional channel
6649         # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6650         # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6651         redirect_url = traverse_obj(
6652             data, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all=False)
6653         if redirect_url and 'no-youtube-channel-redirect' not in compat_opts:
6654             redirect_url = ''.join((urljoin('https://www.youtube.com', redirect_url), tab, post))
6655             self.to_screen(f'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6656             return self.url_result(redirect_url, YoutubeTabIE)
6657
6658         tabs, extra_tabs = self._extract_tab_renderers(data), []
6659         if is_channel and tabs and 'no-youtube-channel-redirect' not in compat_opts:
6660             selected_tab = self._extract_selected_tab(tabs)
6661             selected_tab_id, selected_tab_name = self._extract_tab_id_and_name(selected_tab, url)  # NB: Name may be translated
6662             self.write_debug(f'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6663
6664             # /about is no longer a tab
6665             if original_tab_id == 'about':
6666                 return self._empty_playlist(item_id, data)
6667
6668             if not original_tab_id and selected_tab_name:
6669                 self.to_screen('Downloading all uploads of the channel. '
6670                                'To download only the videos in a specific tab, pass the tab\'s URL')
6671                 if self._has_tab(tabs, 'streams'):
6672                     extra_tabs.append(''.join((pre, '/streams', post)))
6673                 if self._has_tab(tabs, 'shorts'):
6674                     extra_tabs.append(''.join((pre, '/shorts', post)))
6675                 # XXX: Members-only tab should also be extracted
6676
6677                 if not extra_tabs and selected_tab_id != 'videos':
6678                     # Channel does not have streams, shorts or videos tabs
6679                     if item_id[:2] != 'UC':
6680                         return self._empty_playlist(item_id, data)
6681
6682                     # Topic channels don't have /videos. Use the equivalent playlist instead
6683                     pl_id = f'UU{item_id[2:]}'
6684                     pl_url = f'https://www.youtube.com/playlist?list={pl_id}'
6685                     try:
6686                         data, ytcfg = self._extract_data(pl_url, pl_id, ytcfg=ytcfg, fatal=True, webpage_fatal=True)
6687                     except ExtractorError:
6688                         return self._empty_playlist(item_id, data)
6689                     else:
6690                         item_id, url = pl_id, pl_url
6691                         self.to_screen(
6692                             f'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6693
6694                 elif extra_tabs and selected_tab_id != 'videos':
6695                     # When there are shorts/live tabs but not videos tab
6696                     url, data = f'{pre}{post}', None
6697
6698             elif (original_tab_id or 'videos') != selected_tab_id:
6699                 if original_tab_id == 'live':
6700                     # Live tab should have redirected to the video
6701                     # Except in the case the channel has an actual live tab
6702                     # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6703                     raise UserNotLive(video_id=item_id)
6704                 elif selected_tab_name:
6705                     raise ExtractorError(f'This channel does not have a {original_tab_id} tab', expected=True)
6706
6707                 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6708                 url = f'{pre}{post}'
6709
6710         # YouTube sometimes provides a button to reload playlist with unavailable videos.
6711         if 'no-youtube-unavailable-videos' not in compat_opts:
6712             data = self._reload_with_unavailable_videos(display_id, data, ytcfg) or data
6713         self._extract_and_report_alerts(data, only_once=True)
6714
6715         tabs, entries = self._extract_tab_renderers(data), []
6716         if tabs:
6717             entries = [self._extract_from_tabs(item_id, ytcfg, data, tabs)]
6718             entries[0].update({
6719                 'extractor_key': YoutubeTabIE.ie_key(),
6720                 'extractor': YoutubeTabIE.IE_NAME,
6721                 'webpage_url': url,
6722             })
6723         if self.get_param('playlist_items') == '0':
6724             entries.extend(self.url_result(u, YoutubeTabIE) for u in extra_tabs)
6725         else:  # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6726             entries.extend(map(self._real_extract, extra_tabs))
6727
6728         if len(entries) == 1:
6729             return entries[0]
6730         elif entries:
6731             metadata = self._extract_metadata_from_tabs(item_id, data)
6732             uploads_url = 'the Uploads (UU) playlist URL'
6733             if try_get(metadata, lambda x: x['channel_id'].startswith('UC')):
6734                 uploads_url = f'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6735             self.to_screen(
6736                 'Downloading as multiple playlists, separated by tabs. '
6737                 f'To download as a single playlist instead, pass {uploads_url}')
6738             return self.playlist_result(entries, item_id, **metadata)
6739
6740         # Inline playlist
6741         playlist = traverse_obj(
6742             data, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type=dict)
6743         if playlist:
6744             return self._extract_from_playlist(item_id, url, data, playlist, ytcfg)
6745
6746         video_id = traverse_obj(
6747             data, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type=str) or video_id
6748         if video_id:
6749             if tab != '/live':  # live tab is expected to redirect to video
6750                 self.report_warning(f'Unable to recognize playlist. Downloading just video {video_id}')
6751             return self.url_result(f'https://www.youtube.com/watch?v={video_id}', YoutubeIE, video_id)
6752
6753         raise ExtractorError('Unable to recognize tab page')
6754
6755
6756 class YoutubePlaylistIE(InfoExtractor):
6757     IE_DESC = 'YouTube playlists'
6758     _VALID_URL = r'''(?x)(?:
6759                         (?:https?://)?
6760                         (?:\w+\.)?
6761                         (?:
6762                             (?:
6763                                 youtube(?:kids)?\.com|
6764                                 {invidious}
6765                             )
6766                             /.*?\?.*?\blist=
6767                         )?
6768                         (?P<id>{playlist_id})
6769                      )'''.format(
6770         playlist_id=YoutubeBaseInfoExtractor._PLAYLIST_ID_RE,
6771         invidious='|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
6772     )
6773     IE_NAME = 'youtube:playlist'
6774     _TESTS = [{
6775         'note': 'issue #673',
6776         'url': 'PLBB231211A4F62143',
6777         'info_dict': {
6778             'title': '[OLD]Team Fortress 2 (Class-based LP)',
6779             'id': 'PLBB231211A4F62143',
6780             'uploader': 'Wickman',
6781             'uploader_id': '@WickmanVT',
6782             'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6783             'view_count': int,
6784             'uploader_url': 'https://www.youtube.com/@WickmanVT',
6785             'modified_date': r're:\d{8}',
6786             'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6787             'channel': 'Wickman',
6788             'tags': [],
6789             'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6790             'availability': 'public',
6791         },
6792         'playlist_mincount': 29,
6793     }, {
6794         'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6795         'info_dict': {
6796             'title': 'YDL_safe_search',
6797             'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6798         },
6799         'playlist_count': 2,
6800         'skip': 'This playlist is private',
6801     }, {
6802         'note': 'embedded',
6803         'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6804         'playlist_count': 4,
6805         'info_dict': {
6806             'title': 'JODA15',
6807             'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6808             'uploader': 'milan',
6809             'uploader_id': '@milan5503',
6810             'description': '',
6811             'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6812             'tags': [],
6813             'modified_date': '20140919',
6814             'view_count': int,
6815             'channel': 'milan',
6816             'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6817             'uploader_url': 'https://www.youtube.com/@milan5503',
6818             'availability': 'public',
6819         },
6820         'expected_warnings': [r'[Uu]navailable videos? (is|are|will be) hidden', 'Retrying', 'Giving up'],
6821     }, {
6822         'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6823         'playlist_mincount': 455,
6824         'info_dict': {
6825             'title': '2018 Chinese New Singles (11/6 updated)',
6826             'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6827             'uploader': 'LBK',
6828             'uploader_id': '@music_king',
6829             'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6830             'channel': 'LBK',
6831             'view_count': int,
6832             'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6833             'tags': [],
6834             'uploader_url': 'https://www.youtube.com/@music_king',
6835             'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6836             'modified_date': r're:\d{8}',
6837             'availability': 'public',
6838         },
6839         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
6840     }, {
6841         'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6842         'only_matching': True,
6843     }, {
6844         # music album playlist
6845         'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6846         'only_matching': True,
6847     }]
6848
6849     @classmethod
6850     def suitable(cls, url):
6851         if YoutubeTabIE.suitable(url):
6852             return False
6853         from ..utils import parse_qs
6854         qs = parse_qs(url)
6855         if qs.get('v', [None])[0]:
6856             return False
6857         return super().suitable(url)
6858
6859     def _real_extract(self, url):
6860         playlist_id = self._match_id(url)
6861         is_music_url = YoutubeBaseInfoExtractor.is_music_url(url)
6862         url = update_url_query(
6863             'https://www.youtube.com/playlist',
6864             parse_qs(url) or {'list': playlist_id})
6865         if is_music_url:
6866             url = smuggle_url(url, {'is_music_url': True})
6867         return self.url_result(url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
6868
6869
6870 class YoutubeYtBeIE(InfoExtractor):
6871     IE_DESC = 'youtu.be'
6872     _VALID_URL = rf'https?://youtu\.be/(?P<id>[0-9A-Za-z_-]{{11}})/*?.*?\blist=(?P<playlist_id>{YoutubeBaseInfoExtractor._PLAYLIST_ID_RE})'
6873     _TESTS = [{
6874         'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6875         'info_dict': {
6876             'id': 'yeWKywCrFtk',
6877             'ext': 'mp4',
6878             'title': 'Small Scale Baler and Braiding Rugs',
6879             'uploader': 'Backus-Page House Museum',
6880             'uploader_id': '@backuspagemuseum',
6881             'uploader_url': r're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6882             'upload_date': '20161008',
6883             'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6884             'categories': ['Nonprofits & Activism'],
6885             'tags': list,
6886             'like_count': int,
6887             'age_limit': 0,
6888             'playable_in_embed': True,
6889             'thumbnail': r're:^https?://.*\.webp',
6890             'channel': 'Backus-Page House Museum',
6891             'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6892             'live_status': 'not_live',
6893             'view_count': int,
6894             'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6895             'availability': 'public',
6896             'duration': 59,
6897             'comment_count': int,
6898             'channel_follower_count': int,
6899         },
6900         'params': {
6901             'noplaylist': True,
6902             'skip_download': True,
6903         },
6904     }, {
6905         'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6906         'only_matching': True,
6907     }]
6908
6909     def _real_extract(self, url):
6910         mobj = self._match_valid_url(url)
6911         video_id = mobj.group('id')
6912         playlist_id = mobj.group('playlist_id')
6913         return self.url_result(
6914             update_url_query('https://www.youtube.com/watch', {
6915                 'v': video_id,
6916                 'list': playlist_id,
6917                 'feature': 'youtu.be',
6918             }), ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
6919
6920
6921 class YoutubeLivestreamEmbedIE(InfoExtractor):
6922     IE_DESC = 'YouTube livestream embeds'
6923     _VALID_URL = r'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6924     _TESTS = [{
6925         'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6926         'only_matching': True,
6927     }]
6928
6929     def _real_extract(self, url):
6930         channel_id = self._match_id(url)
6931         return self.url_result(
6932             f'https://www.youtube.com/channel/{channel_id}/live',
6933             ie=YoutubeTabIE.ie_key(), video_id=channel_id)
6934
6935
6936 class YoutubeYtUserIE(InfoExtractor):
6937     IE_DESC = 'YouTube user videos; "ytuser:" prefix'
6938     IE_NAME = 'youtube:user'
6939     _VALID_URL = r'ytuser:(?P<id>.+)'
6940     _TESTS = [{
6941         'url': 'ytuser:phihag',
6942         'only_matching': True,
6943     }]
6944
6945     def _real_extract(self, url):
6946         user_id = self._match_id(url)
6947         return self.url_result(f'https://www.youtube.com/user/{user_id}', YoutubeTabIE, user_id)
6948
6949
6950 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
6951     IE_NAME = 'youtube:favorites'
6952     IE_DESC = 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6953     _VALID_URL = r':ytfav(?:ou?rite)?s?'
6954     _LOGIN_REQUIRED = True
6955     _TESTS = [{
6956         'url': ':ytfav',
6957         'only_matching': True,
6958     }, {
6959         'url': ':ytfavorites',
6960         'only_matching': True,
6961     }]
6962
6963     def _real_extract(self, url):
6964         return self.url_result(
6965             'https://www.youtube.com/playlist?list=LL',
6966             ie=YoutubeTabIE.ie_key())
6967
6968
6969 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor):
6970     IE_NAME = 'youtube:notif'
6971     IE_DESC = 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6972     _VALID_URL = r':ytnotif(?:ication)?s?'
6973     _LOGIN_REQUIRED = True
6974     _TESTS = [{
6975         'url': ':ytnotif',
6976         'only_matching': True,
6977     }, {
6978         'url': ':ytnotifications',
6979         'only_matching': True,
6980     }]
6981
6982     def _extract_notification_menu(self, response, continuation_list):
6983         notification_list = traverse_obj(
6984             response,
6985             ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6986             ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6987             expected_type=list) or []
6988         continuation_list[0] = None
6989         for item in notification_list:
6990             entry = self._extract_notification_renderer(item.get('notificationRenderer'))
6991             if entry:
6992                 yield entry
6993             continuation = item.get('continuationItemRenderer')
6994             if continuation:
6995                 continuation_list[0] = continuation
6996
6997     def _extract_notification_renderer(self, notification):
6998         video_id = traverse_obj(
6999             notification, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type=str)
7000         url = f'https://www.youtube.com/watch?v={video_id}'
7001         channel_id = None
7002         if not video_id:
7003             browse_ep = traverse_obj(
7004                 notification, ('navigationEndpoint', 'browseEndpoint'), expected_type=dict)
7005             channel_id = self.ucid_or_none(traverse_obj(browse_ep, 'browseId', expected_type=str))
7006             post_id = self._search_regex(
7007                 r'/post/(.+)', traverse_obj(browse_ep, 'canonicalBaseUrl', expected_type=str),
7008                 'post id', default=None)
7009             if not channel_id or not post_id:
7010                 return
7011             # The direct /post url redirects to this in the browser
7012             url = f'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
7013
7014         channel = traverse_obj(
7015             notification, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
7016             expected_type=str)
7017         notification_title = self._get_text(notification, 'shortMessage')
7018         if notification_title:
7019             notification_title = notification_title.replace('\xad', '')  # remove soft hyphens
7020         # TODO: handle recommended videos
7021         title = self._search_regex(
7022             rf'{re.escape(channel or "")}[^:]+: (.+)', notification_title,
7023             'video title', default=None)
7024         timestamp = (self._parse_time_text(self._get_text(notification, 'sentTimeText'))
7025                      if self._configuration_arg('approximate_date', ie_key=YoutubeTabIE)
7026                      else None)
7027         return {
7028             '_type': 'url',
7029             'url': url,
7030             'ie_key': (YoutubeIE if video_id else YoutubeTabIE).ie_key(),
7031             'video_id': video_id,
7032             'title': title,
7033             'channel_id': channel_id,
7034             'channel': channel,
7035             'uploader': channel,
7036             'thumbnails': self._extract_thumbnails(notification, 'videoThumbnail'),
7037             'timestamp': timestamp,
7038         }
7039
7040     def _notification_menu_entries(self, ytcfg):
7041         continuation_list = [None]
7042         response = None
7043         for page in itertools.count(1):
7044             ctoken = traverse_obj(
7045                 continuation_list, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type=str)
7046             response = self._extract_response(
7047                 item_id=f'page {page}', query={'ctoken': ctoken} if ctoken else {}, ytcfg=ytcfg,
7048                 ep='notification/get_notification_menu', check_get_keys='actions',
7049                 headers=self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response)))
7050             yield from self._extract_notification_menu(response, continuation_list)
7051             if not continuation_list[0]:
7052                 break
7053
7054     def _real_extract(self, url):
7055         display_id = 'notifications'
7056         ytcfg = self._download_ytcfg('web', display_id) if not self.skip_webpage else {}
7057         self._report_playlist_authcheck(ytcfg)
7058         return self.playlist_result(self._notification_menu_entries(ytcfg), display_id, display_id)
7059
7060
7061 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
7062     IE_DESC = 'YouTube search'
7063     IE_NAME = 'youtube:search'
7064     _SEARCH_KEY = 'ytsearch'
7065     _SEARCH_PARAMS = 'EgIQAfABAQ=='  # Videos only
7066     _TESTS = [{
7067         'url': 'ytsearch5:youtube-dl test video',
7068         'playlist_count': 5,
7069         'info_dict': {
7070             'id': 'youtube-dl test video',
7071             'title': 'youtube-dl test video',
7072         },
7073     }, {
7074         'note': 'Suicide/self-harm search warning',
7075         'url': 'ytsearch1:i hate myself and i wanna die',
7076         'playlist_count': 1,
7077         'info_dict': {
7078             'id': 'i hate myself and i wanna die',
7079             'title': 'i hate myself and i wanna die',
7080         },
7081     }]
7082
7083
7084 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
7085     IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
7086     _SEARCH_KEY = 'ytsearchdate'
7087     IE_DESC = 'YouTube search, newest videos first'
7088     _SEARCH_PARAMS = 'CAISAhAB8AEB'  # Videos only, sorted by date
7089     _TESTS = [{
7090         'url': 'ytsearchdate5:youtube-dl test video',
7091         'playlist_count': 5,
7092         'info_dict': {
7093             'id': 'youtube-dl test video',
7094             'title': 'youtube-dl test video',
7095         },
7096     }]
7097
7098
7099 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor):
7100     IE_DESC = 'YouTube search URLs with sorting and filter support'
7101     IE_NAME = YoutubeSearchIE.IE_NAME + '_url'
7102     _VALID_URL = r'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7103     _TESTS = [{
7104         'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
7105         'playlist_mincount': 5,
7106         'info_dict': {
7107             'id': 'youtube-dl test video',
7108             'title': 'youtube-dl test video',
7109         },
7110     }, {
7111         'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
7112         'playlist_mincount': 5,
7113         'info_dict': {
7114             'id': 'python',
7115             'title': 'python',
7116         },
7117     }, {
7118         'url': 'https://www.youtube.com/results?search_query=%23cats',
7119         'playlist_mincount': 1,
7120         'info_dict': {
7121             'id': '#cats',
7122             'title': '#cats',
7123             # The test suite does not have support for nested playlists
7124             # 'entries': [{
7125             #     'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
7126             #     'title': '#cats',
7127             # }],
7128         },
7129     }, {
7130         # Channel results
7131         'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
7132         'info_dict': {
7133             'id': 'kurzgesagt',
7134             'title': 'kurzgesagt',
7135         },
7136         'playlist': [{
7137             'info_dict': {
7138                 '_type': 'url',
7139                 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7140                 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7141                 'ie_key': 'YoutubeTab',
7142                 'channel': 'Kurzgesagt – In a Nutshell',
7143                 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
7144                 'title': 'Kurzgesagt – In a Nutshell',
7145                 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7146                 # No longer available for search as it is set to the handle.
7147                 # 'playlist_count': int,
7148                 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7149                 'thumbnails': list,
7150                 'uploader_id': '@kurzgesagt',
7151                 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7152                 'uploader': 'Kurzgesagt – In a Nutshell',
7153                 'channel_is_verified': True,
7154                 'channel_follower_count': int,
7155             },
7156         }],
7157         'params': {'extract_flat': True, 'playlist_items': '1'},
7158         'playlist_mincount': 1,
7159     }, {
7160         'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7161         'only_matching': True,
7162     }]
7163
7164     def _real_extract(self, url):
7165         qs = parse_qs(url)
7166         query = (qs.get('search_query') or qs.get('q'))[0]
7167         return self.playlist_result(self._search_results(query, qs.get('sp', (None,))[0]), query, query)
7168
7169
7170 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor):
7171     IE_DESC = 'YouTube music search URLs with selectable sections, e.g. #songs'
7172     IE_NAME = 'youtube:music:search_url'
7173     _VALID_URL = r'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7174     _TESTS = [{
7175         'url': 'https://music.youtube.com/search?q=royalty+free+music',
7176         'playlist_count': 16,
7177         'info_dict': {
7178             'id': 'royalty free music',
7179             'title': 'royalty free music',
7180         },
7181     }, {
7182         'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7183         'playlist_mincount': 30,
7184         'info_dict': {
7185             'id': 'royalty free music - songs',
7186             'title': 'royalty free music - songs',
7187         },
7188         'params': {'extract_flat': 'in_playlist'},
7189     }, {
7190         'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7191         'playlist_mincount': 30,
7192         'info_dict': {
7193             'id': 'royalty free music - community playlists',
7194             'title': 'royalty free music - community playlists',
7195         },
7196         'params': {'extract_flat': 'in_playlist'},
7197     }]
7198
7199     _SECTIONS = {
7200         'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7201         'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7202         'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7203         'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7204         'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7205         'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7206     }
7207
7208     def _real_extract(self, url):
7209         qs = parse_qs(url)
7210         query = (qs.get('search_query') or qs.get('q'))[0]
7211         params = qs.get('sp', (None,))[0]
7212         if params:
7213             section = next((k for k, v in self._SECTIONS.items() if v == params), params)
7214         else:
7215             section = urllib.parse.unquote_plus(([*url.split('#'), ''])[1]).lower()
7216             params = self._SECTIONS.get(section)
7217             if not params:
7218                 section = None
7219         title = join_nonempty(query, section, delim=' - ')
7220         return self.playlist_result(self._search_results(query, params, default_client='web_music'), title, title)
7221
7222
7223 class YoutubeFeedsInfoExtractor(InfoExtractor):
7224     """
7225     Base class for feed extractors
7226     Subclasses must re-define the _FEED_NAME property.
7227     """
7228     _LOGIN_REQUIRED = True
7229     _FEED_NAME = 'feeds'
7230
7231     def _real_initialize(self):
7232         YoutubeBaseInfoExtractor._check_login_required(self)
7233
7234     @classproperty
7235     def IE_NAME(cls):
7236         return f'youtube:{cls._FEED_NAME}'
7237
7238     def _real_extract(self, url):
7239         return self.url_result(
7240             f'https://www.youtube.com/feed/{self._FEED_NAME}', ie=YoutubeTabIE.ie_key())
7241
7242
7243 class YoutubeWatchLaterIE(InfoExtractor):
7244     IE_NAME = 'youtube:watchlater'
7245     IE_DESC = 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7246     _VALID_URL = r':ytwatchlater'
7247     _TESTS = [{
7248         'url': ':ytwatchlater',
7249         'only_matching': True,
7250     }]
7251
7252     def _real_extract(self, url):
7253         return self.url_result(
7254             'https://www.youtube.com/playlist?list=WL', ie=YoutubeTabIE.ie_key())
7255
7256
7257 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
7258     IE_DESC = 'YouTube recommended videos; ":ytrec" keyword'
7259     _VALID_URL = r'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7260     _FEED_NAME = 'recommended'
7261     _LOGIN_REQUIRED = False
7262     _TESTS = [{
7263         'url': ':ytrec',
7264         'only_matching': True,
7265     }, {
7266         'url': ':ytrecommended',
7267         'only_matching': True,
7268     }, {
7269         'url': 'https://youtube.com',
7270         'only_matching': True,
7271     }]
7272
7273
7274 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor):
7275     IE_DESC = 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7276     _VALID_URL = r':ytsub(?:scription)?s?'
7277     _FEED_NAME = 'subscriptions'
7278     _TESTS = [{
7279         'url': ':ytsubs',
7280         'only_matching': True,
7281     }, {
7282         'url': ':ytsubscriptions',
7283         'only_matching': True,
7284     }]
7285
7286
7287 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
7288     IE_DESC = 'Youtube watch history; ":ythis" keyword (requires cookies)'
7289     _VALID_URL = r':ythis(?:tory)?'
7290     _FEED_NAME = 'history'
7291     _TESTS = [{
7292         'url': ':ythistory',
7293         'only_matching': True,
7294     }]
7295
7296
7297 class YoutubeShortsAudioPivotIE(InfoExtractor):
7298     IE_DESC = 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7299     IE_NAME = 'youtube:shorts:pivot:audio'
7300     _VALID_URL = r'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7301     _TESTS = [{
7302         'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7303         'only_matching': True,
7304     }]
7305
7306     @staticmethod
7307     def _generate_audio_pivot_params(video_id):
7308         """
7309         Generates sfv_audio_pivot browse params for this video id
7310         """
7311         pb_params = b'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id.encode(),) * 3)
7312         return urllib.parse.quote(base64.b64encode(pb_params).decode())
7313
7314     def _real_extract(self, url):
7315         video_id = self._match_id(url)
7316         return self.url_result(
7317             f'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7318             ie=YoutubeTabIE)
7319
7320
7321 class YoutubeTruncatedURLIE(InfoExtractor):
7322     IE_NAME = 'youtube:truncated_url'
7323     IE_DESC = False  # Do not list
7324     _VALID_URL = r'''(?x)
7325         (?:https?://)?
7326         (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7327         (?:watch\?(?:
7328             feature=[a-z_]+|
7329             annotation_id=annotation_[^&]+|
7330             x-yt-cl=[0-9]+|
7331             hl=[^&]*|
7332             t=[0-9]+
7333         )?
7334         |
7335             attribution_link\?a=[^&]+
7336         )
7337         $
7338     '''
7339
7340     _TESTS = [{
7341         'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7342         'only_matching': True,
7343     }, {
7344         'url': 'https://www.youtube.com/watch?',
7345         'only_matching': True,
7346     }, {
7347         'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7348         'only_matching': True,
7349     }, {
7350         'url': 'https://www.youtube.com/watch?feature=foo',
7351         'only_matching': True,
7352     }, {
7353         'url': 'https://www.youtube.com/watch?hl=en-GB',
7354         'only_matching': True,
7355     }, {
7356         'url': 'https://www.youtube.com/watch?t=2372',
7357         'only_matching': True,
7358     }]
7359
7360     def _real_extract(self, url):
7361         raise ExtractorError(
7362             'Did you forget to quote the URL? Remember that & is a meta '
7363             'character in most shells, so you want to put the URL in quotes, '
7364             'like  youtube-dl '
7365             '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7366             ' or simply  youtube-dl BaW_jenozKc  .',
7367             expected=True)
7368
7369
7370 class YoutubeClipIE(YoutubeTabBaseInfoExtractor):
7371     IE_NAME = 'youtube:clip'
7372     _VALID_URL = r'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7373     _TESTS = [{
7374         # FIXME: Other metadata should be extracted from the clip, not from the base video
7375         'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7376         'info_dict': {
7377             'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7378             'ext': 'mp4',
7379             'section_start': 29.0,
7380             'section_end': 39.7,
7381             'duration': 10.7,
7382             'age_limit': 0,
7383             'availability': 'public',
7384             'categories': ['Gaming'],
7385             'channel': 'Scott The Woz',
7386             'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7387             'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7388             'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7389             'like_count': int,
7390             'playable_in_embed': True,
7391             'tags': 'count:17',
7392             'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7393             'title': 'Mobile Games on Console - Scott The Woz',
7394             'upload_date': '20210920',
7395             'uploader': 'Scott The Woz',
7396             'uploader_id': '@ScottTheWoz',
7397             'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7398             'view_count': int,
7399             'live_status': 'not_live',
7400             'channel_follower_count': int,
7401             'chapters': 'count:20',
7402             'comment_count': int,
7403             'heatmap': 'count:100',
7404         },
7405     }]
7406
7407     def _real_extract(self, url):
7408         clip_id = self._match_id(url)
7409         _, data = self._extract_webpage(url, clip_id)
7410
7411         video_id = traverse_obj(data, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7412         if not video_id:
7413             raise ExtractorError('Unable to find video ID')
7414
7415         clip_data = traverse_obj(data, (
7416             'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7417             'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7418             'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7419             'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all=False)
7420
7421         return {
7422             '_type': 'url_transparent',
7423             'url': f'https://www.youtube.com/watch?v={video_id}',
7424             'ie_key': YoutubeIE.ie_key(),
7425             'id': clip_id,
7426             'section_start': int(clip_data['startTimeMs']) / 1000,
7427             'section_end': int(clip_data['endTimeMs']) / 1000,
7428         }
7429
7430
7431 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor):
7432     IE_NAME = 'youtube:consent'
7433     IE_DESC = False  # Do not list
7434     _VALID_URL = r'https?://consent\.youtube\.com/m\?'
7435     _TESTS = [{
7436         'url': 'https://consent.youtube.com/m?continue=https%3A%2F%2Fwww.youtube.com%2Flive%2FqVv6vCqciTM%3Fcbrd%3D1&gl=NL&m=0&pc=yt&hl=en&src=1',
7437         'info_dict': {
7438             'id': 'qVv6vCqciTM',
7439             'ext': 'mp4',
7440             'age_limit': 0,
7441             'uploader_id': '@sana_natori',
7442             'comment_count': int,
7443             'chapters': 'count:13',
7444             'upload_date': '20221223',
7445             'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7446             'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7447             'uploader_url': 'https://www.youtube.com/@sana_natori',
7448             'like_count': int,
7449             'release_date': '20221223',
7450             'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7451             'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7452             'view_count': int,
7453             'playable_in_embed': True,
7454             'duration': 4438,
7455             'availability': 'public',
7456             'channel_follower_count': int,
7457             'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7458             'categories': ['Entertainment'],
7459             'live_status': 'was_live',
7460             'release_timestamp': 1671793345,
7461             'channel': 'さなちゃんねる',
7462             'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7463             'uploader': 'さなちゃんねる',
7464             'channel_is_verified': True,
7465             'heatmap': 'count:100',
7466         },
7467         'add_ie': ['Youtube'],
7468         'params': {'skip_download': 'Youtube'},
7469     }]
7470
7471     def _real_extract(self, url):
7472         redirect_url = url_or_none(parse_qs(url).get('continue', [None])[-1])
7473         if not redirect_url:
7474             raise ExtractorError('Invalid cookie consent redirect URL', expected=True)
7475         return self.url_result(redirect_url)
7476
7477
7478 class YoutubeTruncatedIDIE(InfoExtractor):
7479     IE_NAME = 'youtube:truncated_id'
7480     IE_DESC = False  # Do not list
7481     _VALID_URL = r'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7482
7483     _TESTS = [{
7484         'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7485         'only_matching': True,
7486     }]
7487
7488     def _real_extract(self, url):
7489         video_id = self._match_id(url)
7490         raise ExtractorError(
7491             f'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',
7492             expected=True)