yt_dlp/extractor/youtube.py

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