yt_dlp/extractor/youtube.py

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