yt_dlp/extractor/youtube.py

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