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'):
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                 'has_drm': bool(fmt.get('drmFamilies')),
3109                 'tbr': tbr,
3110                 'url': fmt_url,
3111                 'width': int_or_none(fmt.get('width')),
3112                 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3113                                           'desc' if language_preference < -1 else ''),
3114                 'language_preference': language_preference,
3115                 # Strictly de-prioritize damaged and 3gp formats
3116                 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3117             }
3118             mime_mobj = re.match(
3119                 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^"]+)")?', fmt.get('mimeType') or '')
3120             if mime_mobj:
3121                 dct['ext'] = mimetype2ext(mime_mobj.group(1))
3122                 dct.update(parse_codecs(mime_mobj.group(2)))
3123             no_audio = dct.get('acodec') == 'none'
3124             no_video = dct.get('vcodec') == 'none'
3125             if no_audio:
3126                 dct['vbr'] = tbr
3127             if no_video:
3128                 dct['abr'] = tbr
3129             if no_audio or no_video:
3130                 dct['downloader_options'] = {
3131                     # Youtube throttles chunks >~10M
3132                     'http_chunk_size': 10485760,
3133                 }
3134                 if dct.get('ext'):
3135                     dct['container'] = dct['ext'] + '_dash'
3136             yield dct
3137
3138         live_from_start = is_live and self.get_param('live_from_start')
3139         skip_manifests = self._configuration_arg('skip')
3140         if not self.get_param('youtube_include_hls_manifest', True):
3141             skip_manifests.append('hls')
3142         get_dash = 'dash' not in skip_manifests and (
3143             not is_live or live_from_start or self._configuration_arg('include_live_dash'))
3144         get_hls = not live_from_start and 'hls' not in skip_manifests
3145
3146         def process_manifest_format(f, proto, itag):
3147             if itag in itags:
3148                 if itags[itag] == proto or f'{itag}-{proto}' in itags:
3149                     return False
3150                 itag = f'{itag}-{proto}'
3151             if itag:
3152                 f['format_id'] = itag
3153                 itags[itag] = proto
3154
3155             f['quality'] = next((
3156                 q(qdict[val])
3157                 for val, qdict in ((f.get('format_id', '').split('-')[0], itag_qualities), (f.get('height'), res_qualities))
3158                 if val in qdict), -1)
3159             return True
3160
3161         for sd in streaming_data:
3162             hls_manifest_url = get_hls and sd.get('hlsManifestUrl')
3163             if hls_manifest_url:
3164                 for f in self._extract_m3u8_formats(hls_manifest_url, video_id, 'mp4', fatal=False):
3165                     if process_manifest_format(f, 'hls', self._search_regex(
3166                             r'/itag/(\d+)', f['url'], 'itag', default=None)):
3167                         yield f
3168
3169             dash_manifest_url = get_dash and sd.get('dashManifestUrl')
3170             if dash_manifest_url:
3171                 for f in self._extract_mpd_formats(dash_manifest_url, video_id, fatal=False):
3172                     if process_manifest_format(f, 'dash', f['format_id']):
3173                         f['filesize'] = int_or_none(self._search_regex(
3174                             r'/clen/(\d+)', f.get('fragment_base_url') or f['url'], 'file size', default=None))
3175                         if live_from_start:
3176                             f['is_from_start'] = True
3177
3178                         yield f
3179
3180     def _extract_storyboard(self, player_responses, duration):
3181         spec = get_first(
3182             player_responses, ('storyboards', 'playerStoryboardSpecRenderer', 'spec'), default='').split('|')[::-1]
3183         base_url = url_or_none(urljoin('https://i.ytimg.com/', spec.pop() or None))
3184         if not base_url:
3185             return
3186         L = len(spec) - 1
3187         for i, args in enumerate(spec):
3188             args = args.split('#')
3189             counts = list(map(int_or_none, args[:5]))
3190             if len(args) != 8 or not all(counts):
3191                 self.report_warning(f'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3192                 continue
3193             width, height, frame_count, cols, rows = counts
3194             N, sigh = args[6:]
3195
3196             url = base_url.replace('$L', str(L - i)).replace('$N', N) + f'&sigh={sigh}'
3197             fragment_count = frame_count / (cols * rows)
3198             fragment_duration = duration / fragment_count
3199             yield {
3200                 'format_id': f'sb{i}',
3201                 'format_note': 'storyboard',
3202                 'ext': 'mhtml',
3203                 'protocol': 'mhtml',
3204                 'acodec': 'none',
3205                 'vcodec': 'none',
3206                 'url': url,
3207                 'width': width,
3208                 'height': height,
3209                 'fragments': [{
3210                     'url': url.replace('$M', str(j)),
3211                     'duration': min(fragment_duration, duration - (j * fragment_duration)),
3212                 } for j in range(math.ceil(fragment_count))],
3213             }
3214
3215     def _download_player_responses(self, url, smuggled_data, video_id, webpage_url):
3216         webpage = None
3217         if 'webpage' not in self._configuration_arg('player_skip'):
3218             webpage = self._download_webpage(
3219                 webpage_url + '&bpctr=9999999999&has_verified=1', video_id, fatal=False)
3220
3221         master_ytcfg = self.extract_ytcfg(video_id, webpage) or self._get_default_ytcfg()
3222
3223         player_responses, player_url = self._extract_player_responses(
3224             self._get_requested_clients(url, smuggled_data),
3225             video_id, webpage, master_ytcfg)
3226
3227         return webpage, master_ytcfg, player_responses, player_url
3228
3229     def _list_formats(self, video_id, microformats, video_details, player_responses, player_url, duration=None):
3230         live_broadcast_details = traverse_obj(microformats, (..., 'liveBroadcastDetails'))
3231         is_live = get_first(video_details, 'isLive')
3232         if is_live is None:
3233             is_live = get_first(live_broadcast_details, 'isLiveNow')
3234
3235         streaming_data = traverse_obj(player_responses, (..., 'streamingData'), default=[])
3236         formats = list(self._extract_formats(streaming_data, video_id, player_url, is_live, duration))
3237
3238         return live_broadcast_details, is_live, streaming_data, formats
3239
3240     def _real_extract(self, url):
3241         url, smuggled_data = unsmuggle_url(url, {})
3242         video_id = self._match_id(url)
3243
3244         base_url = self.http_scheme() + '//www.youtube.com/'
3245         webpage_url = base_url + 'watch?v=' + video_id
3246
3247         webpage, master_ytcfg, player_responses, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
3248
3249         playability_statuses = traverse_obj(
3250             player_responses, (..., 'playabilityStatus'), expected_type=dict, default=[])
3251
3252         trailer_video_id = get_first(
3253             playability_statuses,
3254             ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
3255             expected_type=str)
3256         if trailer_video_id:
3257             return self.url_result(
3258                 trailer_video_id, self.ie_key(), trailer_video_id)
3259
3260         search_meta = ((lambda x: self._html_search_meta(x, webpage, default=None))
3261                        if webpage else (lambda x: None))
3262
3263         video_details = traverse_obj(
3264             player_responses, (..., 'videoDetails'), expected_type=dict, default=[])
3265         microformats = traverse_obj(
3266             player_responses, (..., 'microformat', 'playerMicroformatRenderer'),
3267             expected_type=dict, default=[])
3268         video_title = (
3269             get_first(video_details, 'title')
3270             or self._get_text(microformats, (..., 'title'))
3271             or search_meta(['og:title', 'twitter:title', 'title']))
3272         video_description = get_first(video_details, 'shortDescription')
3273
3274         multifeed_metadata_list = get_first(
3275             player_responses,
3276             ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
3277             expected_type=str)
3278         if multifeed_metadata_list and not smuggled_data.get('force_singlefeed'):
3279             if self.get_param('noplaylist'):
3280                 self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
3281             else:
3282                 entries = []
3283                 feed_ids = []
3284                 for feed in multifeed_metadata_list.split(','):
3285                     # Unquote should take place before split on comma (,) since textual
3286                     # fields may contain comma as well (see
3287                     # https://github.com/ytdl-org/youtube-dl/issues/8536)
3288                     feed_data = compat_parse_qs(
3289                         compat_urllib_parse_unquote_plus(feed))
3290
3291                     def feed_entry(name):
3292                         return try_get(
3293                             feed_data, lambda x: x[name][0], compat_str)
3294
3295                     feed_id = feed_entry('id')
3296                     if not feed_id:
3297                         continue
3298                     feed_title = feed_entry('title')
3299                     title = video_title
3300                     if feed_title:
3301                         title += ' (%s)' % feed_title
3302                     entries.append({
3303                         '_type': 'url_transparent',
3304                         'ie_key': 'Youtube',
3305                         'url': smuggle_url(
3306                             '%swatch?v=%s' % (base_url, feed_data['id'][0]),
3307                             {'force_singlefeed': True}),
3308                         'title': title,
3309                     })
3310                     feed_ids.append(feed_id)
3311                 self.to_screen(
3312                     'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
3313                     % (', '.join(feed_ids), video_id))
3314                 return self.playlist_result(
3315                     entries, video_id, video_title, video_description)
3316
3317         duration = int_or_none(
3318             get_first(video_details, 'lengthSeconds')
3319             or get_first(microformats, 'lengthSeconds')
3320             or parse_duration(search_meta('duration'))) or None
3321
3322         live_broadcast_details, is_live, streaming_data, formats = self._list_formats(
3323             video_id, microformats, video_details, player_responses, player_url, duration)
3324
3325         if not formats:
3326             if not self.get_param('allow_unplayable_formats') and traverse_obj(streaming_data, (..., 'licenseInfos')):
3327                 self.report_drm(video_id)
3328             pemr = get_first(
3329                 playability_statuses,
3330                 ('errorScreen', 'playerErrorMessageRenderer'), expected_type=dict) or {}
3331             reason = self._get_text(pemr, 'reason') or get_first(playability_statuses, 'reason')
3332             subreason = clean_html(self._get_text(pemr, 'subreason') or '')
3333             if subreason:
3334                 if subreason == 'The uploader has not made this video available in your country.':
3335                     countries = get_first(microformats, 'availableCountries')
3336                     if not countries:
3337                         regions_allowed = search_meta('regionsAllowed')
3338                         countries = regions_allowed.split(',') if regions_allowed else None
3339                     self.raise_geo_restricted(subreason, countries, metadata_available=True)
3340                 reason += f'. {subreason}'
3341             if reason:
3342                 self.raise_no_formats(reason, expected=True)
3343
3344         keywords = get_first(video_details, 'keywords', expected_type=list) or []
3345         if not keywords and webpage:
3346             keywords = [
3347                 unescapeHTML(m.group('content'))
3348                 for m in re.finditer(self._meta_regex('og:video:tag'), webpage)]
3349         for keyword in keywords:
3350             if keyword.startswith('yt:stretch='):
3351                 mobj = re.search(r'(\d+)\s*:\s*(\d+)', keyword)
3352                 if mobj:
3353                     # NB: float is intentional for forcing float division
3354                     w, h = (float(v) for v in mobj.groups())
3355                     if w > 0 and h > 0:
3356                         ratio = w / h
3357                         for f in formats:
3358                             if f.get('vcodec') != 'none':
3359                                 f['stretched_ratio'] = ratio
3360                         break
3361         thumbnails = self._extract_thumbnails((video_details, microformats), (..., ..., 'thumbnail'))
3362         thumbnail_url = search_meta(['og:image', 'twitter:image'])
3363         if thumbnail_url:
3364             thumbnails.append({
3365                 'url': thumbnail_url,
3366             })
3367         original_thumbnails = thumbnails.copy()
3368
3369         # The best resolution thumbnails sometimes does not appear in the webpage
3370         # See: https://github.com/ytdl-org/youtube-dl/issues/29049, https://github.com/yt-dlp/yt-dlp/issues/340
3371         # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
3372         thumbnail_names = [
3373             'maxresdefault', 'hq720', 'sddefault', 'sd1', 'sd2', 'sd3',
3374             'hqdefault', 'hq1', 'hq2', 'hq3', '0',
3375             'mqdefault', 'mq1', 'mq2', 'mq3',
3376             'default', '1', '2', '3'
3377         ]
3378         n_thumbnail_names = len(thumbnail_names)
3379         thumbnails.extend({
3380             'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
3381                 video_id=video_id, name=name, ext=ext,
3382                 webp='_webp' if ext == 'webp' else '', live='_live' if is_live else ''),
3383         } for name in thumbnail_names for ext in ('webp', 'jpg'))
3384         for thumb in thumbnails:
3385             i = next((i for i, t in enumerate(thumbnail_names) if f'/{video_id}/{t}' in thumb['url']), n_thumbnail_names)
3386             thumb['preference'] = (0 if '.webp' in thumb['url'] else -1) - (2 * i)
3387         self._remove_duplicate_formats(thumbnails)
3388         self._downloader._sort_thumbnails(original_thumbnails)
3389
3390         category = get_first(microformats, 'category') or search_meta('genre')
3391         channel_id = str_or_none(
3392             get_first(video_details, 'channelId')
3393             or get_first(microformats, 'externalChannelId')
3394             or search_meta('channelId'))
3395         owner_profile_url = get_first(microformats, 'ownerProfileUrl')
3396
3397         live_content = get_first(video_details, 'isLiveContent')
3398         is_upcoming = get_first(video_details, 'isUpcoming')
3399         if is_live is None:
3400             if is_upcoming or live_content is False:
3401                 is_live = False
3402         if is_upcoming is None and (live_content or is_live):
3403             is_upcoming = False
3404         live_start_time = parse_iso8601(get_first(live_broadcast_details, 'startTimestamp'))
3405         live_end_time = parse_iso8601(get_first(live_broadcast_details, 'endTimestamp'))
3406         if not duration and live_end_time and live_start_time:
3407             duration = live_end_time - live_start_time
3408
3409         if is_live and self.get_param('live_from_start'):
3410             self._prepare_live_from_start_formats(formats, video_id, live_start_time, url, webpage_url, smuggled_data)
3411
3412         formats.extend(self._extract_storyboard(player_responses, duration))
3413
3414         # Source is given priority since formats that throttle are given lower source_preference
3415         # When throttling issue is fully fixed, remove this
3416         self._sort_formats(formats, ('quality', 'res', 'fps', 'hdr:12', 'source', 'codec:vp9.2', 'lang', 'proto'))
3417
3418         info = {
3419             'id': video_id,
3420             'title': video_title,
3421             'formats': formats,
3422             'thumbnails': thumbnails,
3423             # The best thumbnail that we are sure exists. Prevents unnecessary
3424             # URL checking if user don't care about getting the best possible thumbnail
3425             'thumbnail': traverse_obj(original_thumbnails, (-1, 'url')),
3426             'description': video_description,
3427             'uploader': get_first(video_details, 'author'),
3428             'uploader_id': self._search_regex(r'/(?:channel|user)/([^/?&#]+)', owner_profile_url, 'uploader id') if owner_profile_url else None,
3429             'uploader_url': owner_profile_url,
3430             'channel_id': channel_id,
3431             'channel_url': format_field(channel_id, template='https://www.youtube.com/channel/%s'),
3432             'duration': duration,
3433             'view_count': int_or_none(
3434                 get_first((video_details, microformats), (..., 'viewCount'))
3435                 or search_meta('interactionCount')),
3436             'average_rating': float_or_none(get_first(video_details, 'averageRating')),
3437             'age_limit': 18 if (
3438                 get_first(microformats, 'isFamilySafe') is False
3439                 or search_meta('isFamilyFriendly') == 'false'
3440                 or search_meta('og:restrictions:age') == '18+') else 0,
3441             'webpage_url': webpage_url,
3442             'categories': [category] if category else None,
3443             'tags': keywords,
3444             'playable_in_embed': get_first(playability_statuses, 'playableInEmbed'),
3445             'is_live': is_live,
3446             'was_live': (False if is_live or is_upcoming or live_content is False
3447                          else None if is_live is None or is_upcoming is None
3448                          else live_content),
3449             'live_status': 'is_upcoming' if is_upcoming else None,  # rest will be set by YoutubeDL
3450             'release_timestamp': live_start_time,
3451         }
3452
3453         pctr = traverse_obj(player_responses, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type=dict)
3454         if pctr:
3455             def get_lang_code(track):
3456                 return (remove_start(track.get('vssId') or '', '.').replace('.', '-')
3457                         or track.get('languageCode'))
3458
3459             # Converted into dicts to remove duplicates
3460             captions = {
3461                 get_lang_code(sub): sub
3462                 for sub in traverse_obj(pctr, (..., 'captionTracks', ...), default=[])}
3463             translation_languages = {
3464                 lang.get('languageCode'): self._get_text(lang.get('languageName'), max_runs=1)
3465                 for lang in traverse_obj(pctr, (..., 'translationLanguages', ...), default=[])}
3466
3467             def process_language(container, base_url, lang_code, sub_name, query):
3468                 lang_subs = container.setdefault(lang_code, [])
3469                 for fmt in self._SUBTITLE_FORMATS:
3470                     query.update({
3471                         'fmt': fmt,
3472                     })
3473                     lang_subs.append({
3474                         'ext': fmt,
3475                         'url': urljoin('https://www.youtube.com', update_url_query(base_url, query)),
3476                         'name': sub_name,
3477                     })
3478
3479             subtitles, automatic_captions = {}, {}
3480             for lang_code, caption_track in captions.items():
3481                 base_url = caption_track.get('baseUrl')
3482                 if not base_url:
3483                     continue
3484                 lang_name = self._get_text(caption_track, 'name', max_runs=1)
3485                 if caption_track.get('kind') != 'asr':
3486                     if not lang_code:
3487                         continue
3488                     process_language(
3489                         subtitles, base_url, lang_code, lang_name, {})
3490                     if not caption_track.get('isTranslatable'):
3491                         continue
3492                 for trans_code, trans_name in translation_languages.items():
3493                     if not trans_code:
3494                         continue
3495                     if caption_track.get('kind') != 'asr':
3496                         trans_code += f'-{lang_code}'
3497                         trans_name += format_field(lang_name, template=' from %s')
3498                     # Add an "-orig" label to the original language so that it can be distinguished.
3499                     # The subs are returned without "-orig" as well for compatibility
3500                     if lang_code == f'a-{trans_code}':
3501                         process_language(
3502                             automatic_captions, base_url, f'{trans_code}-orig', f'{trans_name} (Original)', {})
3503                     # Setting tlang=lang returns damaged subtitles.
3504                     # Not using lang_code == f'a-{trans_code}' here for future-proofing
3505                     orig_lang = parse_qs(base_url).get('lang', [None])[-1]
3506                     process_language(automatic_captions, base_url, trans_code, trans_name,
3507                                      {} if orig_lang == trans_code else {'tlang': trans_code})
3508             info['automatic_captions'] = automatic_captions
3509             info['subtitles'] = subtitles
3510
3511         parsed_url = compat_urllib_parse_urlparse(url)
3512         for component in [parsed_url.fragment, parsed_url.query]:
3513             query = compat_parse_qs(component)
3514             for k, v in query.items():
3515                 for d_k, s_ks in [('start', ('start', 't')), ('end', ('end',))]:
3516                     d_k += '_time'
3517                     if d_k not in info and k in s_ks:
3518                         info[d_k] = parse_duration(query[k][0])
3519
3520         # Youtube Music Auto-generated description
3521         if video_description:
3522             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)
3523             if mobj:
3524                 release_year = mobj.group('release_year')
3525                 release_date = mobj.group('release_date')
3526                 if release_date:
3527                     release_date = release_date.replace('-', '')
3528                     if not release_year:
3529                         release_year = release_date[:4]
3530                 info.update({
3531                     'album': mobj.group('album'.strip()),
3532                     'artist': mobj.group('clean_artist') or ', '.join(a.strip() for a in mobj.group('artist').split('·')),
3533                     'track': mobj.group('track').strip(),
3534                     'release_date': release_date,
3535                     'release_year': int_or_none(release_year),
3536                 })
3537
3538         initial_data = None
3539         if webpage:
3540             initial_data = self._extract_yt_initial_variable(
3541                 webpage, self._YT_INITIAL_DATA_RE, video_id,
3542                 'yt initial data')
3543         if not initial_data:
3544             query = {'videoId': video_id}
3545             query.update(self._get_checkok_params())
3546             initial_data = self._extract_response(
3547                 item_id=video_id, ep='next', fatal=False,
3548                 ytcfg=master_ytcfg, query=query,
3549                 headers=self.generate_api_headers(ytcfg=master_ytcfg),
3550                 note='Downloading initial data API JSON')
3551
3552         try:
3553             # This will error if there is no livechat
3554             initial_data['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
3555             info.setdefault('subtitles', {})['live_chat'] = [{
3556                 'url': 'https://www.youtube.com/watch?v=%s' % video_id,  # url is needed to set cookies
3557                 'video_id': video_id,
3558                 'ext': 'json',
3559                 'protocol': 'youtube_live_chat' if is_live or is_upcoming else 'youtube_live_chat_replay',
3560             }]
3561         except (KeyError, IndexError, TypeError):
3562             pass
3563
3564         if initial_data:
3565             info['chapters'] = (
3566                 self._extract_chapters_from_json(initial_data, duration)
3567                 or self._extract_chapters_from_engagement_panel(initial_data, duration)
3568                 or None)
3569
3570         contents = traverse_obj(
3571             initial_data, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
3572             expected_type=list, default=[])
3573
3574         vpir = get_first(contents, 'videoPrimaryInfoRenderer')
3575         if vpir:
3576             stl = vpir.get('superTitleLink')
3577             if stl:
3578                 stl = self._get_text(stl)
3579                 if try_get(
3580                         vpir,
3581                         lambda x: x['superTitleIcon']['iconType']) == 'LOCATION_PIN':
3582                     info['location'] = stl
3583                 else:
3584                     mobj = re.search(r'(.+?)\s*S(\d+)\s*•\s*E(\d+)', stl)
3585                     if mobj:
3586                         info.update({
3587                             'series': mobj.group(1),
3588                             'season_number': int(mobj.group(2)),
3589                             'episode_number': int(mobj.group(3)),
3590                         })
3591             for tlb in (try_get(
3592                     vpir,
3593                     lambda x: x['videoActions']['menuRenderer']['topLevelButtons'],
3594                     list) or []):
3595                 tbr = tlb.get('toggleButtonRenderer') or {}
3596                 for getter, regex in [(
3597                         lambda x: x['defaultText']['accessibility']['accessibilityData'],
3598                         r'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
3599                             lambda x: x['accessibility'],
3600                             lambda x: x['accessibilityData']['accessibilityData'],
3601                         ], r'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
3602                     label = (try_get(tbr, getter, dict) or {}).get('label')
3603                     if label:
3604                         mobj = re.match(regex, label)
3605                         if mobj:
3606                             info[mobj.group('type') + '_count'] = str_to_int(mobj.group('count'))
3607                             break
3608             sbr_tooltip = try_get(
3609                 vpir, lambda x: x['sentimentBar']['sentimentBarRenderer']['tooltip'])
3610             if sbr_tooltip:
3611                 like_count, dislike_count = sbr_tooltip.split(' / ')
3612                 info.update({
3613                     'like_count': str_to_int(like_count),
3614                     'dislike_count': str_to_int(dislike_count),
3615                 })
3616         vsir = get_first(contents, 'videoSecondaryInfoRenderer')
3617         if vsir:
3618             vor = traverse_obj(vsir, ('owner', 'videoOwnerRenderer'))
3619             info.update({
3620                 'channel': self._get_text(vor, 'title'),
3621                 'channel_follower_count': self._get_count(vor, 'subscriberCountText')})
3622
3623             rows = try_get(
3624                 vsir,
3625                 lambda x: x['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
3626                 list) or []
3627             multiple_songs = False
3628             for row in rows:
3629                 if try_get(row, lambda x: x['metadataRowRenderer']['hasDividerLine']) is True:
3630                     multiple_songs = True
3631                     break
3632             for row in rows:
3633                 mrr = row.get('metadataRowRenderer') or {}
3634                 mrr_title = mrr.get('title')
3635                 if not mrr_title:
3636                     continue
3637                 mrr_title = self._get_text(mrr, 'title')
3638                 mrr_contents_text = self._get_text(mrr, ('contents', 0))
3639                 if mrr_title == 'License':
3640                     info['license'] = mrr_contents_text
3641                 elif not multiple_songs:
3642                     if mrr_title == 'Album':
3643                         info['album'] = mrr_contents_text
3644                     elif mrr_title == 'Artist':
3645                         info['artist'] = mrr_contents_text
3646                     elif mrr_title == 'Song':
3647                         info['track'] = mrr_contents_text
3648
3649         fallbacks = {
3650             'channel': 'uploader',
3651             'channel_id': 'uploader_id',
3652             'channel_url': 'uploader_url',
3653         }
3654
3655         # The upload date for scheduled, live and past live streams / premieres in microformats
3656         # may be different from the stream date. Although not in UTC, we will prefer it in this case.
3657         # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
3658         upload_date = (
3659             unified_strdate(get_first(microformats, 'uploadDate'))
3660             or unified_strdate(search_meta('uploadDate')))
3661         if not upload_date or (not info.get('is_live') and not info.get('was_live') and info.get('live_status') != 'is_upcoming'):
3662             upload_date = strftime_or_none(self._extract_time_text(vpir, 'dateText')[0], '%Y%m%d')
3663         info['upload_date'] = upload_date
3664
3665         for to, frm in fallbacks.items():
3666             if not info.get(to):
3667                 info[to] = info.get(frm)
3668
3669         for s_k, d_k in [('artist', 'creator'), ('track', 'alt_title')]:
3670             v = info.get(s_k)
3671             if v:
3672                 info[d_k] = v
3673
3674         is_private = get_first(video_details, 'isPrivate', expected_type=bool)
3675         is_unlisted = get_first(microformats, 'isUnlisted', expected_type=bool)
3676         is_membersonly = None
3677         is_premium = None
3678         if initial_data and is_private is not None:
3679             is_membersonly = False
3680             is_premium = False
3681             contents = try_get(initial_data, lambda x: x['contents']['twoColumnWatchNextResults']['results']['results']['contents'], list) or []
3682             badge_labels = set()
3683             for content in contents:
3684                 if not isinstance(content, dict):
3685                     continue
3686                 badge_labels.update(self._extract_badges(content.get('videoPrimaryInfoRenderer')))
3687             for badge_label in badge_labels:
3688                 if badge_label.lower() == 'members only':
3689                     is_membersonly = True
3690                 elif badge_label.lower() == 'premium':
3691                     is_premium = True
3692                 elif badge_label.lower() == 'unlisted':
3693                     is_unlisted = True
3694
3695         info['availability'] = self._availability(
3696             is_private=is_private,
3697             needs_premium=is_premium,
3698             needs_subscription=is_membersonly,
3699             needs_auth=info['age_limit'] >= 18,
3700             is_unlisted=None if is_private is None else is_unlisted)
3701
3702         info['__post_extractor'] = self.extract_comments(master_ytcfg, video_id, contents, webpage)
3703
3704         self.mark_watched(video_id, player_responses)
3705
3706         return info
3707
3708
3709 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor):
3710
3711     @staticmethod
3712     def passthrough_smuggled_data(func):
3713         def _smuggle(entries, smuggled_data):
3714             for entry in entries:
3715                 # TODO: Convert URL to music.youtube instead.
3716                 # Do we need to passthrough any other smuggled_data?
3717                 entry['url'] = smuggle_url(entry['url'], smuggled_data)
3718                 yield entry
3719
3720         @functools.wraps(func)
3721         def wrapper(self, url):
3722             url, smuggled_data = unsmuggle_url(url, {})
3723             if self.is_music_url(url):
3724                 smuggled_data['is_music_url'] = True
3725             info_dict = func(self, url, smuggled_data)
3726             if smuggled_data and info_dict.get('entries'):
3727                 info_dict['entries'] = _smuggle(info_dict['entries'], smuggled_data)
3728             return info_dict
3729         return wrapper
3730
3731     def _extract_channel_id(self, webpage):
3732         channel_id = self._html_search_meta(
3733             'channelId', webpage, 'channel id', default=None)
3734         if channel_id:
3735             return channel_id
3736         channel_url = self._html_search_meta(
3737             ('og:url', 'al:ios:url', 'al:android:url', 'al:web:url',
3738              'twitter:url', 'twitter:app:url:iphone', 'twitter:app:url:ipad',
3739              'twitter:app:url:googleplay'), webpage, 'channel url')
3740         return self._search_regex(
3741             r'https?://(?:www\.)?youtube\.com/channel/([^/?#&])+',
3742             channel_url, 'channel id')
3743
3744     @staticmethod
3745     def _extract_basic_item_renderer(item):
3746         # Modified from _extract_grid_item_renderer
3747         known_basic_renderers = (
3748             'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer'
3749         )
3750         for key, renderer in item.items():
3751             if not isinstance(renderer, dict):
3752                 continue
3753             elif key in known_basic_renderers:
3754                 return renderer
3755             elif key.startswith('grid') and key.endswith('Renderer'):
3756                 return renderer
3757
3758     def _grid_entries(self, grid_renderer):
3759         for item in grid_renderer['items']:
3760             if not isinstance(item, dict):
3761                 continue
3762             renderer = self._extract_basic_item_renderer(item)
3763             if not isinstance(renderer, dict):
3764                 continue
3765             title = self._get_text(renderer, 'title')
3766
3767             # playlist
3768             playlist_id = renderer.get('playlistId')
3769             if playlist_id:
3770                 yield self.url_result(
3771                     'https://www.youtube.com/playlist?list=%s' % playlist_id,
3772                     ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
3773                     video_title=title)
3774                 continue
3775             # video
3776             video_id = renderer.get('videoId')
3777             if video_id:
3778                 yield self._extract_video(renderer)
3779                 continue
3780             # channel
3781             channel_id = renderer.get('channelId')
3782             if channel_id:
3783                 yield self.url_result(
3784                     'https://www.youtube.com/channel/%s' % channel_id,
3785                     ie=YoutubeTabIE.ie_key(), video_title=title)
3786                 continue
3787             # generic endpoint URL support
3788             ep_url = urljoin('https://www.youtube.com/', try_get(
3789                 renderer, lambda x: x['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
3790                 compat_str))
3791             if ep_url:
3792                 for ie in (YoutubeTabIE, YoutubePlaylistIE, YoutubeIE):
3793                     if ie.suitable(ep_url):
3794                         yield self.url_result(
3795                             ep_url, ie=ie.ie_key(), video_id=ie._match_id(ep_url), video_title=title)
3796                         break
3797
3798     def _music_reponsive_list_entry(self, renderer):
3799         video_id = traverse_obj(renderer, ('playlistItemData', 'videoId'))
3800         if video_id:
3801             return self.url_result(f'https://music.youtube.com/watch?v={video_id}',
3802                                    ie=YoutubeIE.ie_key(), video_id=video_id)
3803         playlist_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
3804         if playlist_id:
3805             video_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
3806             if video_id:
3807                 return self.url_result(f'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
3808                                        ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3809             return self.url_result(f'https://music.youtube.com/playlist?list={playlist_id}',
3810                                    ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3811         browse_id = traverse_obj(renderer, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
3812         if browse_id:
3813             return self.url_result(f'https://music.youtube.com/browse/{browse_id}',
3814                                    ie=YoutubeTabIE.ie_key(), video_id=browse_id)
3815
3816     def _shelf_entries_from_content(self, shelf_renderer):
3817         content = shelf_renderer.get('content')
3818         if not isinstance(content, dict):
3819             return
3820         renderer = content.get('gridRenderer') or content.get('expandedShelfContentsRenderer')
3821         if renderer:
3822             # TODO: add support for nested playlists so each shelf is processed
3823             # as separate playlist
3824             # TODO: this includes only first N items
3825             for entry in self._grid_entries(renderer):
3826                 yield entry
3827         renderer = content.get('horizontalListRenderer')
3828         if renderer:
3829             # TODO
3830             pass
3831
3832     def _shelf_entries(self, shelf_renderer, skip_channels=False):
3833         ep = try_get(
3834             shelf_renderer, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
3835             compat_str)
3836         shelf_url = urljoin('https://www.youtube.com', ep)
3837         if shelf_url:
3838             # Skipping links to another channels, note that checking for
3839             # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
3840             # will not work
3841             if skip_channels and '/channels?' in shelf_url:
3842                 return
3843             title = self._get_text(shelf_renderer, 'title')
3844             yield self.url_result(shelf_url, video_title=title)
3845         # Shelf may not contain shelf URL, fallback to extraction from content
3846         for entry in self._shelf_entries_from_content(shelf_renderer):
3847             yield entry
3848
3849     def _playlist_entries(self, video_list_renderer):
3850         for content in video_list_renderer['contents']:
3851             if not isinstance(content, dict):
3852                 continue
3853             renderer = content.get('playlistVideoRenderer') or content.get('playlistPanelVideoRenderer')
3854             if not isinstance(renderer, dict):
3855                 continue
3856             video_id = renderer.get('videoId')
3857             if not video_id:
3858                 continue
3859             yield self._extract_video(renderer)
3860
3861     def _rich_entries(self, rich_grid_renderer):
3862         renderer = try_get(
3863             rich_grid_renderer, lambda x: x['content']['videoRenderer'], dict) or {}
3864         video_id = renderer.get('videoId')
3865         if not video_id:
3866             return
3867         yield self._extract_video(renderer)
3868
3869     def _video_entry(self, video_renderer):
3870         video_id = video_renderer.get('videoId')
3871         if video_id:
3872             return self._extract_video(video_renderer)
3873
3874     def _post_thread_entries(self, post_thread_renderer):
3875         post_renderer = try_get(
3876             post_thread_renderer, lambda x: x['post']['backstagePostRenderer'], dict)
3877         if not post_renderer:
3878             return
3879         # video attachment
3880         video_renderer = try_get(
3881             post_renderer, lambda x: x['backstageAttachment']['videoRenderer'], dict) or {}
3882         video_id = video_renderer.get('videoId')
3883         if video_id:
3884             entry = self._extract_video(video_renderer)
3885             if entry:
3886                 yield entry
3887         # playlist attachment
3888         playlist_id = try_get(
3889             post_renderer, lambda x: x['backstageAttachment']['playlistRenderer']['playlistId'], compat_str)
3890         if playlist_id:
3891             yield self.url_result(
3892                 'https://www.youtube.com/playlist?list=%s' % playlist_id,
3893                 ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3894         # inline video links
3895         runs = try_get(post_renderer, lambda x: x['contentText']['runs'], list) or []
3896         for run in runs:
3897             if not isinstance(run, dict):
3898                 continue
3899             ep_url = try_get(
3900                 run, lambda x: x['navigationEndpoint']['urlEndpoint']['url'], compat_str)
3901             if not ep_url:
3902                 continue
3903             if not YoutubeIE.suitable(ep_url):
3904                 continue
3905             ep_video_id = YoutubeIE._match_id(ep_url)
3906             if video_id == ep_video_id:
3907                 continue
3908             yield self.url_result(ep_url, ie=YoutubeIE.ie_key(), video_id=ep_video_id)
3909
3910     def _post_thread_continuation_entries(self, post_thread_continuation):
3911         contents = post_thread_continuation.get('contents')
3912         if not isinstance(contents, list):
3913             return
3914         for content in contents:
3915             renderer = content.get('backstagePostThreadRenderer')
3916             if not isinstance(renderer, dict):
3917                 continue
3918             for entry in self._post_thread_entries(renderer):
3919                 yield entry
3920
3921     r''' # unused
3922     def _rich_grid_entries(self, contents):
3923         for content in contents:
3924             video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
3925             if video_renderer:
3926                 entry = self._video_entry(video_renderer)
3927                 if entry:
3928                     yield entry
3929     '''
3930
3931     def _extract_entries(self, parent_renderer, continuation_list):
3932         # continuation_list is modified in-place with continuation_list = [continuation_token]
3933         continuation_list[:] = [None]
3934         contents = try_get(parent_renderer, lambda x: x['contents'], list) or []
3935         for content in contents:
3936             if not isinstance(content, dict):
3937                 continue
3938             is_renderer = traverse_obj(
3939                 content, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
3940                 expected_type=dict)
3941             if not is_renderer:
3942                 renderer = content.get('richItemRenderer')
3943                 if renderer:
3944                     for entry in self._rich_entries(renderer):
3945                         yield entry
3946                     continuation_list[0] = self._extract_continuation(parent_renderer)
3947                 continue
3948             isr_contents = try_get(is_renderer, lambda x: x['contents'], list) or []
3949             for isr_content in isr_contents:
3950                 if not isinstance(isr_content, dict):
3951                     continue
3952
3953                 known_renderers = {
3954                     'playlistVideoListRenderer': self._playlist_entries,
3955                     'gridRenderer': self._grid_entries,
3956                     'shelfRenderer': lambda x: self._shelf_entries(x),
3957                     'musicResponsiveListItemRenderer': lambda x: [self._music_reponsive_list_entry(x)],
3958                     'backstagePostThreadRenderer': self._post_thread_entries,
3959                     'videoRenderer': lambda x: [self._video_entry(x)],
3960                     'playlistRenderer': lambda x: self._grid_entries({'items': [{'playlistRenderer': x}]}),
3961                     'channelRenderer': lambda x: self._grid_entries({'items': [{'channelRenderer': x}]}),
3962                 }
3963                 for key, renderer in isr_content.items():
3964                     if key not in known_renderers:
3965                         continue
3966                     for entry in known_renderers[key](renderer):
3967                         if entry:
3968                             yield entry
3969                     continuation_list[0] = self._extract_continuation(renderer)
3970                     break
3971
3972             if not continuation_list[0]:
3973                 continuation_list[0] = self._extract_continuation(is_renderer)
3974
3975         if not continuation_list[0]:
3976             continuation_list[0] = self._extract_continuation(parent_renderer)
3977
3978     def _entries(self, tab, item_id, ytcfg, account_syncid, visitor_data):
3979         continuation_list = [None]
3980         extract_entries = lambda x: self._extract_entries(x, continuation_list)
3981         tab_content = try_get(tab, lambda x: x['content'], dict)
3982         if not tab_content:
3983             return
3984         parent_renderer = (
3985             try_get(tab_content, lambda x: x['sectionListRenderer'], dict)
3986             or try_get(tab_content, lambda x: x['richGridRenderer'], dict) or {})
3987         for entry in extract_entries(parent_renderer):
3988             yield entry
3989         continuation = continuation_list[0]
3990
3991         for page_num in itertools.count(1):
3992             if not continuation:
3993                 break
3994             headers = self.generate_api_headers(
3995                 ytcfg=ytcfg, account_syncid=account_syncid, visitor_data=visitor_data)
3996             response = self._extract_response(
3997                 item_id='%s page %s' % (item_id, page_num),
3998                 query=continuation, headers=headers, ytcfg=ytcfg,
3999                 check_get_keys=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4000
4001             if not response:
4002                 break
4003             # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4004             # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4005             visitor_data = self._extract_visitor_data(response) or visitor_data
4006
4007             known_continuation_renderers = {
4008                 'playlistVideoListContinuation': self._playlist_entries,
4009                 'gridContinuation': self._grid_entries,
4010                 'itemSectionContinuation': self._post_thread_continuation_entries,
4011                 'sectionListContinuation': extract_entries,  # for feeds
4012             }
4013             continuation_contents = try_get(
4014                 response, lambda x: x['continuationContents'], dict) or {}
4015             continuation_renderer = None
4016             for key, value in continuation_contents.items():
4017                 if key not in known_continuation_renderers:
4018                     continue
4019                 continuation_renderer = value
4020                 continuation_list = [None]
4021                 for entry in known_continuation_renderers[key](continuation_renderer):
4022                     yield entry
4023                 continuation = continuation_list[0] or self._extract_continuation(continuation_renderer)
4024                 break
4025             if continuation_renderer:
4026                 continue
4027
4028             known_renderers = {
4029                 'videoRenderer': (self._grid_entries, 'items'),  # for membership tab
4030                 'gridPlaylistRenderer': (self._grid_entries, 'items'),
4031                 'gridVideoRenderer': (self._grid_entries, 'items'),
4032                 'gridChannelRenderer': (self._grid_entries, 'items'),
4033                 'playlistVideoRenderer': (self._playlist_entries, 'contents'),
4034                 'itemSectionRenderer': (extract_entries, 'contents'),  # for feeds
4035                 'richItemRenderer': (extract_entries, 'contents'),  # for hashtag
4036                 'backstagePostThreadRenderer': (self._post_thread_continuation_entries, 'contents')
4037             }
4038             on_response_received = dict_get(response, ('onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4039             continuation_items = try_get(
4040                 on_response_received, lambda x: x[0]['appendContinuationItemsAction']['continuationItems'], list)
4041             continuation_item = try_get(continuation_items, lambda x: x[0], dict) or {}
4042             video_items_renderer = None
4043             for key, value in continuation_item.items():
4044                 if key not in known_renderers:
4045                     continue
4046                 video_items_renderer = {known_renderers[key][1]: continuation_items}
4047                 continuation_list = [None]
4048                 for entry in known_renderers[key][0](video_items_renderer):
4049                     yield entry
4050                 continuation = continuation_list[0] or self._extract_continuation(video_items_renderer)
4051                 break
4052             if video_items_renderer:
4053                 continue
4054             break
4055
4056     @staticmethod
4057     def _extract_selected_tab(tabs, fatal=True):
4058         for tab in tabs:
4059             renderer = dict_get(tab, ('tabRenderer', 'expandableTabRenderer')) or {}
4060             if renderer.get('selected') is True:
4061                 return renderer
4062         else:
4063             if fatal:
4064                 raise ExtractorError('Unable to find selected tab')
4065
4066     @classmethod
4067     def _extract_uploader(cls, data):
4068         uploader = {}
4069         renderer = cls._extract_sidebar_info_renderer(data, 'playlistSidebarSecondaryInfoRenderer') or {}
4070         owner = try_get(
4071             renderer, lambda x: x['videoOwner']['videoOwnerRenderer']['title']['runs'][0], dict)
4072         if owner:
4073             uploader['uploader'] = owner.get('text')
4074             uploader['uploader_id'] = try_get(
4075                 owner, lambda x: x['navigationEndpoint']['browseEndpoint']['browseId'], compat_str)
4076             uploader['uploader_url'] = urljoin(
4077                 'https://www.youtube.com/',
4078                 try_get(owner, lambda x: x['navigationEndpoint']['browseEndpoint']['canonicalBaseUrl'], compat_str))
4079         return {k: v for k, v in uploader.items() if v is not None}
4080
4081     def _extract_from_tabs(self, item_id, ytcfg, data, tabs):
4082         playlist_id = title = description = channel_url = channel_name = channel_id = None
4083         tags = []
4084
4085         selected_tab = self._extract_selected_tab(tabs)
4086         primary_sidebar_renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer')
4087         renderer = try_get(
4088             data, lambda x: x['metadata']['channelMetadataRenderer'], dict)
4089         if renderer:
4090             channel_name = renderer.get('title')
4091             channel_url = renderer.get('channelUrl')
4092             channel_id = renderer.get('externalId')
4093         else:
4094             renderer = try_get(
4095                 data, lambda x: x['metadata']['playlistMetadataRenderer'], dict)
4096
4097         if renderer:
4098             title = renderer.get('title')
4099             description = renderer.get('description', '')
4100             playlist_id = channel_id
4101             tags = renderer.get('keywords', '').split()
4102
4103         # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4104         # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4105         def _get_uncropped(url):
4106             return url_or_none((url or '').split('=')[0] + '=s0')
4107
4108         avatar_thumbnails = self._extract_thumbnails(renderer, 'avatar')
4109         if avatar_thumbnails:
4110             uncropped_avatar = _get_uncropped(avatar_thumbnails[0]['url'])
4111             if uncropped_avatar:
4112                 avatar_thumbnails.append({
4113                     'url': uncropped_avatar,
4114                     'id': 'avatar_uncropped',
4115                     'preference': 1
4116                 })
4117
4118         channel_banners = self._extract_thumbnails(
4119             data, ('header', ..., ['banner', 'mobileBanner', 'tvBanner']))
4120         for banner in channel_banners:
4121             banner['preference'] = -10
4122
4123         if channel_banners:
4124             uncropped_banner = _get_uncropped(channel_banners[0]['url'])
4125             if uncropped_banner:
4126                 channel_banners.append({
4127                     'url': uncropped_banner,
4128                     'id': 'banner_uncropped',
4129                     'preference': -5
4130                 })
4131
4132         primary_thumbnails = self._extract_thumbnails(
4133             primary_sidebar_renderer, ('thumbnailRenderer', 'playlistVideoThumbnailRenderer', 'thumbnail'))
4134
4135         if playlist_id is None:
4136             playlist_id = item_id
4137
4138         playlist_stats = traverse_obj(primary_sidebar_renderer, 'stats')
4139         last_updated_unix, _ = self._extract_time_text(playlist_stats, 2)
4140         if title is None:
4141             title = self._get_text(data, ('header', 'hashtagHeaderRenderer', 'hashtag')) or playlist_id
4142         title += format_field(selected_tab, 'title', ' - %s')
4143         title += format_field(selected_tab, 'expandedText', ' - %s')
4144
4145         metadata = {
4146             'playlist_id': playlist_id,
4147             'playlist_title': title,
4148             'playlist_description': description,
4149             'uploader': channel_name,
4150             'uploader_id': channel_id,
4151             'uploader_url': channel_url,
4152             'thumbnails': primary_thumbnails + avatar_thumbnails + channel_banners,
4153             'tags': tags,
4154             'view_count': self._get_count(playlist_stats, 1),
4155             'availability': self._extract_availability(data),
4156             'modified_date': strftime_or_none(last_updated_unix, '%Y%m%d'),
4157             'playlist_count': self._get_count(playlist_stats, 0),
4158             'channel_follower_count': self._get_count(data, ('header', ..., 'subscriberCountText')),
4159         }
4160         if not channel_id:
4161             metadata.update(self._extract_uploader(data))
4162         metadata.update({
4163             'channel': metadata['uploader'],
4164             'channel_id': metadata['uploader_id'],
4165             'channel_url': metadata['uploader_url']})
4166         return self.playlist_result(
4167             self._entries(
4168                 selected_tab, playlist_id, ytcfg,
4169                 self._extract_account_syncid(ytcfg, data),
4170                 self._extract_visitor_data(data, ytcfg)),
4171             **metadata)
4172
4173     def _extract_mix_playlist(self, playlist, playlist_id, data, ytcfg):
4174         first_id = last_id = response = None
4175         for page_num in itertools.count(1):
4176             videos = list(self._playlist_entries(playlist))
4177             if not videos:
4178                 return
4179             start = next((i for i, v in enumerate(videos) if v['id'] == last_id), -1) + 1
4180             if start >= len(videos):
4181                 return
4182             for video in videos[start:]:
4183                 if video['id'] == first_id:
4184                     self.to_screen('First video %s found again; Assuming end of Mix' % first_id)
4185                     return
4186                 yield video
4187             first_id = first_id or videos[0]['id']
4188             last_id = videos[-1]['id']
4189             watch_endpoint = try_get(
4190                 playlist, lambda x: x['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
4191             headers = self.generate_api_headers(
4192                 ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
4193                 visitor_data=self._extract_visitor_data(response, data, ytcfg))
4194             query = {
4195                 'playlistId': playlist_id,
4196                 'videoId': watch_endpoint.get('videoId') or last_id,
4197                 'index': watch_endpoint.get('index') or len(videos),
4198                 'params': watch_endpoint.get('params') or 'OAE%3D'
4199             }
4200             response = self._extract_response(
4201                 item_id='%s page %d' % (playlist_id, page_num),
4202                 query=query, ep='next', headers=headers, ytcfg=ytcfg,
4203                 check_get_keys='contents'
4204             )
4205             playlist = try_get(
4206                 response, lambda x: x['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
4207
4208     def _extract_from_playlist(self, item_id, url, data, playlist, ytcfg):
4209         title = playlist.get('title') or try_get(
4210             data, lambda x: x['titleText']['simpleText'], compat_str)
4211         playlist_id = playlist.get('playlistId') or item_id
4212
4213         # Delegating everything except mix playlists to regular tab-based playlist URL
4214         playlist_url = urljoin(url, try_get(
4215             playlist, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4216             compat_str))
4217         if playlist_url and playlist_url != url:
4218             return self.url_result(
4219                 playlist_url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
4220                 video_title=title)
4221
4222         return self.playlist_result(
4223             self._extract_mix_playlist(playlist, playlist_id, data, ytcfg),
4224             playlist_id=playlist_id, playlist_title=title)
4225
4226     def _extract_availability(self, data):
4227         """
4228         Gets the availability of a given playlist/tab.
4229         Note: Unless YouTube tells us explicitly, we do not assume it is public
4230         @param data: response
4231         """
4232         is_private = is_unlisted = None
4233         renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer') or {}
4234         badge_labels = self._extract_badges(renderer)
4235
4236         # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
4237         privacy_dropdown_entries = try_get(
4238             renderer, lambda x: x['privacyForm']['dropdownFormFieldRenderer']['dropdown']['dropdownRenderer']['entries'], list) or []
4239         for renderer_dict in privacy_dropdown_entries:
4240             is_selected = try_get(
4241                 renderer_dict, lambda x: x['privacyDropdownItemRenderer']['isSelected'], bool) or False
4242             if not is_selected:
4243                 continue
4244             label = self._get_text(renderer_dict, ('privacyDropdownItemRenderer', 'label'))
4245             if label:
4246                 badge_labels.add(label.lower())
4247                 break
4248
4249         for badge_label in badge_labels:
4250             if badge_label == 'unlisted':
4251                 is_unlisted = True
4252             elif badge_label == 'private':
4253                 is_private = True
4254             elif badge_label == 'public':
4255                 is_unlisted = is_private = False
4256         return self._availability(is_private, False, False, False, is_unlisted)
4257
4258     @staticmethod
4259     def _extract_sidebar_info_renderer(data, info_renderer, expected_type=dict):
4260         sidebar_renderer = try_get(
4261             data, lambda x: x['sidebar']['playlistSidebarRenderer']['items'], list) or []
4262         for item in sidebar_renderer:
4263             renderer = try_get(item, lambda x: x[info_renderer], expected_type)
4264             if renderer:
4265                 return renderer
4266
4267     def _reload_with_unavailable_videos(self, item_id, data, ytcfg):
4268         """
4269         Get playlist with unavailable videos if the 'show unavailable videos' button exists.
4270         """
4271         browse_id = params = None
4272         renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer')
4273         if not renderer:
4274             return
4275         menu_renderer = try_get(
4276             renderer, lambda x: x['menu']['menuRenderer']['items'], list) or []
4277         for menu_item in menu_renderer:
4278             if not isinstance(menu_item, dict):
4279                 continue
4280             nav_item_renderer = menu_item.get('menuNavigationItemRenderer')
4281             text = try_get(
4282                 nav_item_renderer, lambda x: x['text']['simpleText'], compat_str)
4283             if not text or text.lower() != 'show unavailable videos':
4284                 continue
4285             browse_endpoint = try_get(
4286                 nav_item_renderer, lambda x: x['navigationEndpoint']['browseEndpoint'], dict) or {}
4287             browse_id = browse_endpoint.get('browseId')
4288             params = browse_endpoint.get('params')
4289             break
4290
4291         headers = self.generate_api_headers(
4292             ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
4293             visitor_data=self._extract_visitor_data(data, ytcfg))
4294         query = {
4295             'params': params or 'wgYCCAA=',
4296             'browseId': browse_id or 'VL%s' % item_id
4297         }
4298         return self._extract_response(
4299             item_id=item_id, headers=headers, query=query,
4300             check_get_keys='contents', fatal=False, ytcfg=ytcfg,
4301             note='Downloading API JSON with unavailable videos')
4302
4303     def _extract_webpage(self, url, item_id, fatal=True):
4304         retries = self.get_param('extractor_retries', 3)
4305         count = -1
4306         webpage = data = last_error = None
4307         while count < retries:
4308             count += 1
4309             # Sometimes youtube returns a webpage with incomplete ytInitialData
4310             # See: https://github.com/yt-dlp/yt-dlp/issues/116
4311             if last_error:
4312                 self.report_warning('%s. Retrying ...' % last_error)
4313             try:
4314                 webpage = self._download_webpage(
4315                     url, item_id,
4316                     note='Downloading webpage%s' % (' (retry #%d)' % count if count else '',))
4317                 data = self.extract_yt_initial_data(item_id, webpage or '', fatal=fatal) or {}
4318             except ExtractorError as e:
4319                 if isinstance(e.cause, network_exceptions):
4320                     if not isinstance(e.cause, compat_HTTPError) or e.cause.code not in (403, 429):
4321                         last_error = error_to_compat_str(e.cause or e.msg)
4322                         if count < retries:
4323                             continue
4324                 if fatal:
4325                     raise
4326                 self.report_warning(error_to_compat_str(e))
4327                 break
4328             else:
4329                 try:
4330                     self._extract_and_report_alerts(data)
4331                 except ExtractorError as e:
4332                     if fatal:
4333                         raise
4334                     self.report_warning(error_to_compat_str(e))
4335                     break
4336
4337                 if dict_get(data, ('contents', 'currentVideoEndpoint', 'onResponseReceivedActions')):
4338                     break
4339
4340                 last_error = 'Incomplete yt initial data received'
4341                 if count >= retries:
4342                     if fatal:
4343                         raise ExtractorError(last_error)
4344                     self.report_warning(last_error)
4345                     break
4346
4347         return webpage, data
4348
4349     def _extract_data(self, url, item_id, ytcfg=None, fatal=True, webpage_fatal=False, default_client='web'):
4350         data = None
4351         if 'webpage' not in self._configuration_arg('skip'):
4352             webpage, data = self._extract_webpage(url, item_id, fatal=webpage_fatal)
4353             ytcfg = ytcfg or self.extract_ytcfg(item_id, webpage)
4354             # Reject webpage data if redirected to home page without explicitly requesting
4355             selected_tab = self._extract_selected_tab(traverse_obj(
4356                 data, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs'), expected_type=list, default=[]), fatal=False) or {}
4357             if (url != 'https://www.youtube.com/feed/recommended'
4358                     and selected_tab.get('tabIdentifier') == 'FEwhat_to_watch'  # Home page
4359                     and 'no-youtube-channel-redirect' not in self.get_param('compat_opts', [])):
4360                 msg = 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
4361                 if fatal:
4362                     raise ExtractorError(msg, expected=True)
4363                 self.report_warning(msg, only_once=True)
4364         if not data:
4365             if not ytcfg and self.is_authenticated:
4366                 msg = 'Playlists that require authentication may not extract correctly without a successful webpage download.'
4367                 if 'authcheck' not in self._configuration_arg('skip') and fatal:
4368                     raise ExtractorError(
4369                         msg + ' If you are not downloading private content, or your cookies are only for the first account and channel,'
4370                               ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
4371                         expected=True)
4372                 self.report_warning(msg, only_once=True)
4373             data = self._extract_tab_endpoint(url, item_id, ytcfg, fatal=fatal, default_client=default_client)
4374         return data, ytcfg
4375
4376     def _extract_tab_endpoint(self, url, item_id, ytcfg=None, fatal=True, default_client='web'):
4377         headers = self.generate_api_headers(ytcfg=ytcfg, default_client=default_client)
4378         resolve_response = self._extract_response(
4379             item_id=item_id, query={'url': url}, check_get_keys='endpoint', headers=headers, ytcfg=ytcfg, fatal=fatal,
4380             ep='navigation/resolve_url', note='Downloading API parameters API JSON', default_client=default_client)
4381         endpoints = {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
4382         for ep_key, ep in endpoints.items():
4383             params = try_get(resolve_response, lambda x: x['endpoint'][ep_key], dict)
4384             if params:
4385                 return self._extract_response(
4386                     item_id=item_id, query=params, ep=ep, headers=headers,
4387                     ytcfg=ytcfg, fatal=fatal, default_client=default_client,
4388                     check_get_keys=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
4389         err_note = 'Failed to resolve url (does the playlist exist?)'
4390         if fatal:
4391             raise ExtractorError(err_note, expected=True)
4392         self.report_warning(err_note, item_id)
4393
4394     _SEARCH_PARAMS = None
4395
4396     def _search_results(self, query, params=NO_DEFAULT, default_client='web'):
4397         data = {'query': query}
4398         if params is NO_DEFAULT:
4399             params = self._SEARCH_PARAMS
4400         if params:
4401             data['params'] = params
4402
4403         content_keys = (
4404             ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
4405             ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
4406             # ytmusic search
4407             ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
4408             ('continuationContents', ),
4409         )
4410         check_get_keys = tuple(set(keys[0] for keys in content_keys))
4411
4412         continuation_list = [None]
4413         for page_num in itertools.count(1):
4414             data.update(continuation_list[0] or {})
4415             search = self._extract_response(
4416                 item_id='query "%s" page %s' % (query, page_num), ep='search', query=data,
4417                 default_client=default_client, check_get_keys=check_get_keys)
4418             slr_contents = traverse_obj(search, *content_keys)
4419             yield from self._extract_entries({'contents': list(variadic(slr_contents))}, continuation_list)
4420             if not continuation_list[0]:
4421                 break
4422
4423
4424 class YoutubeTabIE(YoutubeTabBaseInfoExtractor):
4425     IE_DESC = 'YouTube Tabs'
4426     _VALID_URL = r'''(?x:
4427         https?://
4428             (?:\w+\.)?
4429             (?:
4430                 youtube(?:kids)?\.com|
4431                 %(invidious)s
4432             )/
4433             (?:
4434                 (?P<channel_type>channel|c|user|browse)/|
4435                 (?P<not_channel>
4436                     feed/|hashtag/|
4437                     (?:playlist|watch)\?.*?\blist=
4438                 )|
4439                 (?!(?:%(reserved_names)s)\b)  # Direct URLs
4440             )
4441             (?P<id>[^/?\#&]+)
4442     )''' % {
4443         'reserved_names': YoutubeBaseInfoExtractor._RESERVED_NAMES,
4444         'invidious': '|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
4445     }
4446     IE_NAME = 'youtube:tab'
4447
4448     _TESTS = [{
4449         'note': 'playlists, multipage',
4450         'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
4451         'playlist_mincount': 94,
4452         'info_dict': {
4453             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
4454             'title': 'Igor Kleiner - Playlists',
4455             'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
4456             'uploader': 'Igor Kleiner',
4457             'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4458             'channel': 'Igor Kleiner',
4459             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4460             'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
4461             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4462             'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4463             'channel_follower_count': int
4464         },
4465     }, {
4466         'note': 'playlists, multipage, different order',
4467         'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
4468         'playlist_mincount': 94,
4469         'info_dict': {
4470             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
4471             'title': 'Igor Kleiner - Playlists',
4472             'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
4473             'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4474             'uploader': 'Igor Kleiner',
4475             'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4476             'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
4477             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4478             'channel': 'Igor Kleiner',
4479             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4480             'channel_follower_count': int
4481         },
4482     }, {
4483         'note': 'playlists, series',
4484         'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
4485         'playlist_mincount': 5,
4486         'info_dict': {
4487             'id': 'UCYO_jab_esuFRV4b17AJtAw',
4488             'title': '3Blue1Brown - Playlists',
4489             'description': 'md5:e1384e8a133307dd10edee76e875d62f',
4490             'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
4491             'uploader': '3Blue1Brown',
4492             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4493             'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4494             'channel': '3Blue1Brown',
4495             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
4496             'tags': ['Mathematics'],
4497             'channel_follower_count': int
4498         },
4499     }, {
4500         'note': 'playlists, singlepage',
4501         'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
4502         'playlist_mincount': 4,
4503         'info_dict': {
4504             'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4505             'title': 'ThirstForScience - Playlists',
4506             'description': 'md5:609399d937ea957b0f53cbffb747a14c',
4507             'uploader': 'ThirstForScience',
4508             'uploader_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4509             'uploader_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
4510             'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
4511             'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4512             'tags': 'count:13',
4513             'channel': 'ThirstForScience',
4514             'channel_follower_count': int
4515         }
4516     }, {
4517         'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
4518         'only_matching': True,
4519     }, {
4520         'note': 'basic, single video playlist',
4521         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4522         'info_dict': {
4523             'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4524             'uploader': 'Sergey M.',
4525             'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4526             'title': 'youtube-dl public playlist',
4527             'description': '',
4528             'tags': [],
4529             'view_count': int,
4530             'modified_date': '20201130',
4531             'channel': 'Sergey M.',
4532             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4533             'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4534             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4535         },
4536         'playlist_count': 1,
4537     }, {
4538         'note': 'empty playlist',
4539         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
4540         'info_dict': {
4541             'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4542             'uploader': 'Sergey M.',
4543             'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
4544             'title': 'youtube-dl empty playlist',
4545             'tags': [],
4546             'channel': 'Sergey M.',
4547             'description': '',
4548             'modified_date': '20160902',
4549             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4550             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4551             'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4552         },
4553         'playlist_count': 0,
4554     }, {
4555         'note': 'Home tab',
4556         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
4557         'info_dict': {
4558             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4559             'title': 'lex will - Home',
4560             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4561             'uploader': 'lex will',
4562             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4563             'channel': 'lex will',
4564             'tags': ['bible', 'history', 'prophesy'],
4565             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4566             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4567             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4568             'channel_follower_count': int
4569         },
4570         'playlist_mincount': 2,
4571     }, {
4572         'note': 'Videos tab',
4573         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
4574         'info_dict': {
4575             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4576             'title': 'lex will - Videos',
4577             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4578             'uploader': 'lex will',
4579             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4580             'tags': ['bible', 'history', 'prophesy'],
4581             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4582             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4583             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4584             'channel': 'lex will',
4585             'channel_follower_count': int
4586         },
4587         'playlist_mincount': 975,
4588     }, {
4589         'note': 'Videos tab, sorted by popular',
4590         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
4591         'info_dict': {
4592             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4593             'title': 'lex will - Videos',
4594             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4595             'uploader': 'lex will',
4596             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4597             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4598             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4599             'channel': 'lex will',
4600             'tags': ['bible', 'history', 'prophesy'],
4601             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4602             'channel_follower_count': int
4603         },
4604         'playlist_mincount': 199,
4605     }, {
4606         'note': 'Playlists tab',
4607         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
4608         'info_dict': {
4609             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4610             'title': 'lex will - Playlists',
4611             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4612             'uploader': 'lex will',
4613             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4614             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4615             'channel': 'lex will',
4616             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4617             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4618             'tags': ['bible', 'history', 'prophesy'],
4619             'channel_follower_count': int
4620         },
4621         'playlist_mincount': 17,
4622     }, {
4623         'note': 'Community tab',
4624         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
4625         'info_dict': {
4626             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4627             'title': 'lex will - Community',
4628             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4629             'uploader': 'lex will',
4630             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4631             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4632             'channel': 'lex will',
4633             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4634             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4635             'tags': ['bible', 'history', 'prophesy'],
4636             'channel_follower_count': int
4637         },
4638         'playlist_mincount': 18,
4639     }, {
4640         'note': 'Channels tab',
4641         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
4642         'info_dict': {
4643             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4644             'title': 'lex will - Channels',
4645             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4646             'uploader': 'lex will',
4647             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4648             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4649             'channel': 'lex will',
4650             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4651             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4652             'tags': ['bible', 'history', 'prophesy'],
4653             'channel_follower_count': int
4654         },
4655         'playlist_mincount': 12,
4656     }, {
4657         'note': 'Search tab',
4658         'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
4659         'playlist_mincount': 40,
4660         'info_dict': {
4661             'id': 'UCYO_jab_esuFRV4b17AJtAw',
4662             'title': '3Blue1Brown - Search - linear algebra',
4663             'description': 'md5:e1384e8a133307dd10edee76e875d62f',
4664             'uploader': '3Blue1Brown',
4665             'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
4666             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4667             'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4668             'tags': ['Mathematics'],
4669             'channel': '3Blue1Brown',
4670             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
4671             'channel_follower_count': int
4672         },
4673     }, {
4674         'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4675         'only_matching': True,
4676     }, {
4677         'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4678         'only_matching': True,
4679     }, {
4680         'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4681         'only_matching': True,
4682     }, {
4683         'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
4684         'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
4685         'info_dict': {
4686             'title': '29C3: Not my department',
4687             'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
4688             'uploader': 'Christiaan008',
4689             'uploader_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
4690             'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
4691             'tags': [],
4692             'uploader_url': 'https://www.youtube.com/c/ChRiStIaAn008',
4693             'view_count': int,
4694             'modified_date': '20150605',
4695             'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
4696             'channel_url': 'https://www.youtube.com/c/ChRiStIaAn008',
4697             'channel': 'Christiaan008',
4698         },
4699         'playlist_count': 96,
4700     }, {
4701         'note': 'Large playlist',
4702         'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
4703         'info_dict': {
4704             'title': 'Uploads from Cauchemar',
4705             'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
4706             'uploader': 'Cauchemar',
4707             'uploader_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
4708             'channel_url': 'https://www.youtube.com/c/Cauchemar89',
4709             'tags': [],
4710             'modified_date': r're:\d{8}',
4711             'channel': 'Cauchemar',
4712             'uploader_url': 'https://www.youtube.com/c/Cauchemar89',
4713             'view_count': int,
4714             'description': '',
4715             'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
4716         },
4717         'playlist_mincount': 1123,
4718         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4719     }, {
4720         'note': 'even larger playlist, 8832 videos',
4721         'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
4722         'only_matching': True,
4723     }, {
4724         'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
4725         'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
4726         'info_dict': {
4727             'title': 'Uploads from Interstellar Movie',
4728             'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
4729             'uploader': 'Interstellar Movie',
4730             'uploader_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
4731             'uploader_url': 'https://www.youtube.com/c/InterstellarMovie',
4732             'tags': [],
4733             'view_count': int,
4734             'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
4735             'channel_url': 'https://www.youtube.com/c/InterstellarMovie',
4736             'channel': 'Interstellar Movie',
4737             'description': '',
4738             'modified_date': r're:\d{8}',
4739         },
4740         'playlist_mincount': 21,
4741     }, {
4742         'note': 'Playlist with "show unavailable videos" button',
4743         'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
4744         'info_dict': {
4745             'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
4746             'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
4747             'uploader': 'Phim Siêu Nhân Nhật Bản',
4748             'uploader_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
4749             'view_count': int,
4750             'channel': 'Phim Siêu Nhân Nhật Bản',
4751             'tags': [],
4752             'uploader_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
4753             'description': '',
4754             'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
4755             'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
4756             'modified_date': r're:\d{8}',
4757         },
4758         'playlist_mincount': 200,
4759         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4760     }, {
4761         'note': 'Playlist with unavailable videos in page 7',
4762         'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
4763         'info_dict': {
4764             'title': 'Uploads from BlankTV',
4765             'id': 'UU8l9frL61Yl5KFOl87nIm2w',
4766             'uploader': 'BlankTV',
4767             'uploader_id': 'UC8l9frL61Yl5KFOl87nIm2w',
4768             'channel': 'BlankTV',
4769             'channel_url': 'https://www.youtube.com/c/blanktv',
4770             'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
4771             'view_count': int,
4772             'tags': [],
4773             'uploader_url': 'https://www.youtube.com/c/blanktv',
4774             'modified_date': r're:\d{8}',
4775             'description': '',
4776         },
4777         'playlist_mincount': 1000,
4778         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4779     }, {
4780         'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
4781         'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
4782         'info_dict': {
4783             'title': 'Data Analysis with Dr Mike Pound',
4784             'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
4785             'uploader_id': 'UC9-y-6csu5WGm29I7JiwpnA',
4786             'uploader': 'Computerphile',
4787             'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
4788             'uploader_url': 'https://www.youtube.com/user/Computerphile',
4789             'tags': [],
4790             'view_count': int,
4791             'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
4792             'channel_url': 'https://www.youtube.com/user/Computerphile',
4793             'channel': 'Computerphile',
4794         },
4795         'playlist_mincount': 11,
4796     }, {
4797         'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4798         'only_matching': True,
4799     }, {
4800         'note': 'Playlist URL that does not actually serve a playlist',
4801         'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
4802         'info_dict': {
4803             'id': 'FqZTN594JQw',
4804             'ext': 'webm',
4805             'title': "Smiley's People 01 detective, Adventure Series, Action",
4806             'uploader': 'STREEM',
4807             'uploader_id': 'UCyPhqAZgwYWZfxElWVbVJng',
4808             'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCyPhqAZgwYWZfxElWVbVJng',
4809             'upload_date': '20150526',
4810             'license': 'Standard YouTube License',
4811             'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
4812             'categories': ['People & Blogs'],
4813             'tags': list,
4814             'view_count': int,
4815             'like_count': int,
4816         },
4817         'params': {
4818             'skip_download': True,
4819         },
4820         'skip': 'This video is not available.',
4821         'add_ie': [YoutubeIE.ie_key()],
4822     }, {
4823         'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
4824         'only_matching': True,
4825     }, {
4826         'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
4827         'only_matching': True,
4828     }, {
4829         'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
4830         'info_dict': {
4831             'id': 'GgL890LIznQ',  # This will keep changing
4832             'ext': 'mp4',
4833             'title': str,
4834             'uploader': 'Sky News',
4835             'uploader_id': 'skynews',
4836             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/skynews',
4837             'upload_date': r're:\d{8}',
4838             'description': str,
4839             'categories': ['News & Politics'],
4840             'tags': list,
4841             'like_count': int,
4842             'release_timestamp': 1642502819,
4843             'channel': 'Sky News',
4844             'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
4845             'age_limit': 0,
4846             'view_count': int,
4847             'thumbnail': 'https://i.ytimg.com/vi/GgL890LIznQ/maxresdefault_live.jpg',
4848             'playable_in_embed': True,
4849             'release_date': '20220118',
4850             'availability': 'public',
4851             'live_status': 'is_live',
4852             'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
4853             'channel_follower_count': int
4854         },
4855         'params': {
4856             'skip_download': True,
4857         },
4858         'expected_warnings': ['Ignoring subtitle tracks found in '],
4859     }, {
4860         'url': 'https://www.youtube.com/user/TheYoungTurks/live',
4861         'info_dict': {
4862             'id': 'a48o2S1cPoo',
4863             'ext': 'mp4',
4864             'title': 'The Young Turks - Live Main Show',
4865             'uploader': 'The Young Turks',
4866             'uploader_id': 'TheYoungTurks',
4867             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/TheYoungTurks',
4868             'upload_date': '20150715',
4869             'license': 'Standard YouTube License',
4870             'description': 'md5:438179573adcdff3c97ebb1ee632b891',
4871             'categories': ['News & Politics'],
4872             'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
4873             'like_count': int,
4874         },
4875         'params': {
4876             'skip_download': True,
4877         },
4878         'only_matching': True,
4879     }, {
4880         'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
4881         'only_matching': True,
4882     }, {
4883         'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
4884         'only_matching': True,
4885     }, {
4886         'note': 'A channel that is not live. Should raise error',
4887         'url': 'https://www.youtube.com/user/numberphile/live',
4888         'only_matching': True,
4889     }, {
4890         'url': 'https://www.youtube.com/feed/trending',
4891         'only_matching': True,
4892     }, {
4893         'url': 'https://www.youtube.com/feed/library',
4894         'only_matching': True,
4895     }, {
4896         'url': 'https://www.youtube.com/feed/history',
4897         'only_matching': True,
4898     }, {
4899         'url': 'https://www.youtube.com/feed/subscriptions',
4900         'only_matching': True,
4901     }, {
4902         'url': 'https://www.youtube.com/feed/watch_later',
4903         'only_matching': True,
4904     }, {
4905         'note': 'Recommended - redirects to home page.',
4906         'url': 'https://www.youtube.com/feed/recommended',
4907         'only_matching': True,
4908     }, {
4909         'note': 'inline playlist with not always working continuations',
4910         'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
4911         'only_matching': True,
4912     }, {
4913         'url': 'https://www.youtube.com/course',
4914         'only_matching': True,
4915     }, {
4916         'url': 'https://www.youtube.com/zsecurity',
4917         'only_matching': True,
4918     }, {
4919         'url': 'http://www.youtube.com/NASAgovVideo/videos',
4920         'only_matching': True,
4921     }, {
4922         'url': 'https://www.youtube.com/TheYoungTurks/live',
4923         'only_matching': True,
4924     }, {
4925         'url': 'https://www.youtube.com/hashtag/cctv9',
4926         'info_dict': {
4927             'id': 'cctv9',
4928             'title': '#cctv9',
4929             'tags': [],
4930         },
4931         'playlist_mincount': 350,
4932     }, {
4933         'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
4934         'only_matching': True,
4935     }, {
4936         'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
4937         'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4938         'only_matching': True
4939     }, {
4940         'note': '/browse/ should redirect to /channel/',
4941         'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
4942         'only_matching': True
4943     }, {
4944         'note': 'VLPL, should redirect to playlist?list=PL...',
4945         'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4946         'info_dict': {
4947             'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4948             'uploader': 'NoCopyrightSounds',
4949             'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
4950             'uploader_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
4951             'title': 'NCS Releases',
4952             'uploader_url': 'https://www.youtube.com/c/NoCopyrightSounds',
4953             'channel_url': 'https://www.youtube.com/c/NoCopyrightSounds',
4954             'modified_date': r're:\d{8}',
4955             'view_count': int,
4956             'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
4957             'tags': [],
4958             'channel': 'NoCopyrightSounds',
4959         },
4960         'playlist_mincount': 166,
4961         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4962     }, {
4963         'note': 'Topic, should redirect to playlist?list=UU...',
4964         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
4965         'info_dict': {
4966             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
4967             'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4968             'title': 'Uploads from Royalty Free Music - Topic',
4969             'uploader': 'Royalty Free Music - Topic',
4970             'tags': [],
4971             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4972             'channel': 'Royalty Free Music - Topic',
4973             'view_count': int,
4974             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4975             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4976             'modified_date': r're:\d{8}',
4977             'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4978             'description': '',
4979         },
4980         'expected_warnings': [
4981             'The URL does not have a videos tab',
4982             r'[Uu]navailable videos (are|will be) hidden',
4983         ],
4984         'playlist_mincount': 101,
4985     }, {
4986         'note': 'Topic without a UU playlist',
4987         'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
4988         'info_dict': {
4989             'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
4990             'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
4991             'tags': [],
4992         },
4993         'expected_warnings': [
4994             'the playlist redirect gave error',
4995         ],
4996         'playlist_mincount': 9,
4997     }, {
4998         'note': 'Youtube music Album',
4999         'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5000         'info_dict': {
5001             'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5002             'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5003             'tags': [],
5004             'view_count': int,
5005             'description': '',
5006             'availability': 'unlisted',
5007             'modified_date': r're:\d{8}',
5008         },
5009         'playlist_count': 50,
5010     }, {
5011         'note': 'unlisted single video playlist',
5012         'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5013         'info_dict': {
5014             'uploader_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5015             'uploader': 'colethedj',
5016             'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5017             'title': 'yt-dlp unlisted playlist test',
5018             'availability': 'unlisted',
5019             'tags': [],
5020             'modified_date': '20211208',
5021             'channel': 'colethedj',
5022             'view_count': int,
5023             'description': '',
5024             'uploader_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5025             'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5026             'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5027         },
5028         'playlist_count': 1,
5029     }, {
5030         'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5031         'url': 'https://www.youtube.com/feed/recommended',
5032         'info_dict': {
5033             'id': 'recommended',
5034             'title': 'recommended',
5035             'tags': [],
5036         },
5037         'playlist_mincount': 50,
5038         'params': {
5039             'skip_download': True,
5040             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
5041         },
5042     }, {
5043         'note': 'API Fallback: /videos tab, sorted by oldest first',
5044         'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5045         'info_dict': {
5046             'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5047             'title': 'Cody\'sLab - Videos',
5048             'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5049             'uploader': 'Cody\'sLab',
5050             'uploader_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5051             'channel': 'Cody\'sLab',
5052             'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5053             'tags': [],
5054             'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5055             'uploader_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5056             'channel_follower_count': int
5057         },
5058         'playlist_mincount': 650,
5059         'params': {
5060             'skip_download': True,
5061             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
5062         },
5063     }, {
5064         'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5065         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5066         'info_dict': {
5067             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5068             'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5069             'title': 'Uploads from Royalty Free Music - Topic',
5070             'uploader': 'Royalty Free Music - Topic',
5071             'modified_date': r're:\d{8}',
5072             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5073             'description': '',
5074             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5075             'tags': [],
5076             'channel': 'Royalty Free Music - Topic',
5077             'view_count': int,
5078             'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5079         },
5080         'expected_warnings': [
5081             'does not have a videos tab',
5082             r'[Uu]navailable videos (are|will be) hidden',
5083         ],
5084         'playlist_mincount': 101,
5085         'params': {
5086             'skip_download': True,
5087             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
5088         },
5089     }, {
5090         'note': 'non-standard redirect to regional channel',
5091         'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5092         'only_matching': True
5093     }]
5094
5095     @classmethod
5096     def suitable(cls, url):
5097         return False if YoutubeIE.suitable(url) else super(
5098             YoutubeTabIE, cls).suitable(url)
5099
5100     _URL_RE = re.compile(rf'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/\w+))?(?P<post>.*)$')
5101
5102     @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
5103     def _real_extract(self, url, smuggled_data):
5104         item_id = self._match_id(url)
5105         url = compat_urlparse.urlunparse(
5106             compat_urlparse.urlparse(url)._replace(netloc='www.youtube.com'))
5107         compat_opts = self.get_param('compat_opts', [])
5108
5109         def get_mobj(url):
5110             mobj = self._URL_RE.match(url).groupdict()
5111             mobj.update((k, '') for k, v in mobj.items() if v is None)
5112             return mobj
5113
5114         mobj, redirect_warning = get_mobj(url), None
5115         # Youtube returns incomplete data if tabname is not lower case
5116         pre, tab, post, is_channel = mobj['pre'], mobj['tab'].lower(), mobj['post'], not mobj['not_channel']
5117         if is_channel:
5118             if smuggled_data.get('is_music_url'):
5119                 if item_id[:2] == 'VL':  # Youtube music VL channels have an equivalent playlist
5120                     item_id = item_id[2:]
5121                     pre, tab, post, is_channel = f'https://www.youtube.com/playlist?list={item_id}', '', '', False
5122                 elif item_id[:2] == 'MP':  # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
5123                     mdata = self._extract_tab_endpoint(
5124                         f'https://music.youtube.com/channel/{item_id}', item_id, default_client='web_music')
5125                     murl = traverse_obj(mdata, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
5126                                         get_all=False, expected_type=compat_str)
5127                     if not murl:
5128                         raise ExtractorError('Failed to resolve album to playlist')
5129                     return self.url_result(murl, ie=YoutubeTabIE.ie_key())
5130                 elif mobj['channel_type'] == 'browse':  # Youtube music /browse/ should be changed to /channel/
5131                     pre = f'https://www.youtube.com/channel/{item_id}'
5132
5133         original_tab_name = tab
5134         if is_channel and not tab and 'no-youtube-channel-redirect' not in compat_opts:
5135             # Home URLs should redirect to /videos/
5136             redirect_warning = ('A channel/user page was given. All the channel\'s videos will be downloaded. '
5137                                 'To download only the videos in the home page, add a "/featured" to the URL')
5138             tab = '/videos'
5139
5140         url = ''.join((pre, tab, post))
5141         mobj = get_mobj(url)
5142
5143         # Handle both video/playlist URLs
5144         qs = parse_qs(url)
5145         video_id, playlist_id = [qs.get(key, [None])[0] for key in ('v', 'list')]
5146
5147         if not video_id and mobj['not_channel'].startswith('watch'):
5148             if not playlist_id:
5149                 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
5150                 raise ExtractorError('Unable to recognize tab page')
5151             # Common mistake: https://www.youtube.com/watch?list=playlist_id
5152             self.report_warning(f'A video URL was given without video ID. Trying to download playlist {playlist_id}')
5153             url = f'https://www.youtube.com/playlist?list={playlist_id}'
5154             mobj = get_mobj(url)
5155
5156         if video_id and playlist_id:
5157             if self.get_param('noplaylist'):
5158                 self.to_screen(f'Downloading just video {video_id} because of --no-playlist')
5159                 return self.url_result(f'https://www.youtube.com/watch?v={video_id}',
5160                                        ie=YoutubeIE.ie_key(), video_id=video_id)
5161             self.to_screen(f'Downloading playlist {playlist_id}; add --no-playlist to just download video {video_id}')
5162
5163         data, ytcfg = self._extract_data(url, item_id)
5164
5165         # YouTube may provide a non-standard redirect to the regional channel
5166         # See: https://github.com/yt-dlp/yt-dlp/issues/2694
5167         redirect_url = traverse_obj(
5168             data, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all=False)
5169         if redirect_url and 'no-youtube-channel-redirect' not in compat_opts:
5170             redirect_url = ''.join((
5171                 urljoin('https://www.youtube.com', redirect_url), mobj['tab'], mobj['post']))
5172             self.to_screen(f'This playlist is likely not available in your region. Following redirect to regional playlist {redirect_url}')
5173             return self.url_result(redirect_url, ie=YoutubeTabIE.ie_key())
5174
5175         tabs = traverse_obj(data, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs'), expected_type=list)
5176         if tabs:
5177             selected_tab = self._extract_selected_tab(tabs)
5178             selected_tab_name = selected_tab.get('title', '').lower()
5179             if selected_tab_name == 'home':
5180                 selected_tab_name = 'featured'
5181             requested_tab_name = mobj['tab'][1:]
5182             if 'no-youtube-channel-redirect' not in compat_opts:
5183                 if requested_tab_name == 'live':
5184                     # Live tab should have redirected to the video
5185                     raise ExtractorError('The channel is not currently live', expected=True)
5186                 if requested_tab_name not in ('', selected_tab_name):
5187                     redirect_warning = f'The channel does not have a {requested_tab_name} tab'
5188                     if not original_tab_name:
5189                         if item_id[:2] == 'UC':
5190                             # Topic channels don't have /videos. Use the equivalent playlist instead
5191                             pl_id = f'UU{item_id[2:]}'
5192                             pl_url = f'https://www.youtube.com/playlist?list={pl_id}'
5193                             try:
5194                                 data, ytcfg = self._extract_data(pl_url, pl_id, ytcfg=ytcfg, fatal=True, webpage_fatal=True)
5195                             except ExtractorError:
5196                                 redirect_warning += ' and the playlist redirect gave error'
5197                             else:
5198                                 item_id, url, selected_tab_name = pl_id, pl_url, requested_tab_name
5199                                 redirect_warning += f'. Redirecting to playlist {pl_id} instead'
5200                         if selected_tab_name and selected_tab_name != requested_tab_name:
5201                             redirect_warning += f'. {selected_tab_name} tab is being downloaded instead'
5202                     else:
5203                         raise ExtractorError(redirect_warning, expected=True)
5204
5205         if redirect_warning:
5206             self.to_screen(redirect_warning)
5207         self.write_debug(f'Final URL: {url}')
5208
5209         # YouTube sometimes provides a button to reload playlist with unavailable videos.
5210         if 'no-youtube-unavailable-videos' not in compat_opts:
5211             data = self._reload_with_unavailable_videos(item_id, data, ytcfg) or data
5212         self._extract_and_report_alerts(data, only_once=True)
5213         tabs = traverse_obj(data, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs'), expected_type=list)
5214         if tabs:
5215             return self._extract_from_tabs(item_id, ytcfg, data, tabs)
5216
5217         playlist = traverse_obj(
5218             data, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type=dict)
5219         if playlist:
5220             return self._extract_from_playlist(item_id, url, data, playlist, ytcfg)
5221
5222         video_id = traverse_obj(
5223             data, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type=str) or video_id
5224         if video_id:
5225             if mobj['tab'] != '/live':  # live tab is expected to redirect to video
5226                 self.report_warning(f'Unable to recognize playlist. Downloading just video {video_id}')
5227             return self.url_result(f'https://www.youtube.com/watch?v={video_id}',
5228                                    ie=YoutubeIE.ie_key(), video_id=video_id)
5229
5230         raise ExtractorError('Unable to recognize tab page')
5231
5232
5233 class YoutubePlaylistIE(InfoExtractor):
5234     IE_DESC = 'YouTube playlists'
5235     _VALID_URL = r'''(?x)(?:
5236                         (?:https?://)?
5237                         (?:\w+\.)?
5238                         (?:
5239                             (?:
5240                                 youtube(?:kids)?\.com|
5241                                 %(invidious)s
5242                             )
5243                             /.*?\?.*?\blist=
5244                         )?
5245                         (?P<id>%(playlist_id)s)
5246                      )''' % {
5247         'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE,
5248         'invidious': '|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
5249     }
5250     IE_NAME = 'youtube:playlist'
5251     _TESTS = [{
5252         'note': 'issue #673',
5253         'url': 'PLBB231211A4F62143',
5254         'info_dict': {
5255             'title': '[OLD]Team Fortress 2 (Class-based LP)',
5256             'id': 'PLBB231211A4F62143',
5257             'uploader': 'Wickman',
5258             'uploader_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
5259             'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
5260             'view_count': int,
5261             'uploader_url': 'https://www.youtube.com/user/Wickydoo',
5262             'modified_date': r're:\d{8}',
5263             'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
5264             'channel': 'Wickman',
5265             'tags': [],
5266             'channel_url': 'https://www.youtube.com/user/Wickydoo',
5267         },
5268         'playlist_mincount': 29,
5269     }, {
5270         'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
5271         'info_dict': {
5272             'title': 'YDL_safe_search',
5273             'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
5274         },
5275         'playlist_count': 2,
5276         'skip': 'This playlist is private',
5277     }, {
5278         'note': 'embedded',
5279         'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
5280         'playlist_count': 4,
5281         'info_dict': {
5282             'title': 'JODA15',
5283             'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
5284             'uploader': 'milan',
5285             'uploader_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
5286             'description': '',
5287             'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
5288             'tags': [],
5289             'modified_date': '20140919',
5290             'view_count': int,
5291             'channel': 'milan',
5292             'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
5293             'uploader_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
5294         },
5295         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5296     }, {
5297         'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
5298         'playlist_mincount': 654,
5299         'info_dict': {
5300             'title': '2018 Chinese New Singles (11/6 updated)',
5301             'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
5302             'uploader': 'LBK',
5303             'uploader_id': 'UC21nz3_MesPLqtDqwdvnoxA',
5304             'description': 'md5:da521864744d60a198e3a88af4db0d9d',
5305             'channel': 'LBK',
5306             'view_count': int,
5307             'channel_url': 'https://www.youtube.com/c/愛低音的國王',
5308             'tags': [],
5309             'uploader_url': 'https://www.youtube.com/c/愛低音的國王',
5310             'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
5311             'modified_date': r're:\d{8}',
5312         },
5313         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5314     }, {
5315         'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
5316         'only_matching': True,
5317     }, {
5318         # music album playlist
5319         'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
5320         'only_matching': True,
5321     }]
5322
5323     @classmethod
5324     def suitable(cls, url):
5325         if YoutubeTabIE.suitable(url):
5326             return False
5327         from ..utils import parse_qs
5328         qs = parse_qs(url)
5329         if qs.get('v', [None])[0]:
5330             return False
5331         return super(YoutubePlaylistIE, cls).suitable(url)
5332
5333     def _real_extract(self, url):
5334         playlist_id = self._match_id(url)
5335         is_music_url = YoutubeBaseInfoExtractor.is_music_url(url)
5336         url = update_url_query(
5337             'https://www.youtube.com/playlist',
5338             parse_qs(url) or {'list': playlist_id})
5339         if is_music_url:
5340             url = smuggle_url(url, {'is_music_url': True})
5341         return self.url_result(url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
5342
5343
5344 class YoutubeYtBeIE(InfoExtractor):
5345     IE_DESC = 'youtu.be'
5346     _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}
5347     _TESTS = [{
5348         'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
5349         'info_dict': {
5350             'id': 'yeWKywCrFtk',
5351             'ext': 'mp4',
5352             'title': 'Small Scale Baler and Braiding Rugs',
5353             'uploader': 'Backus-Page House Museum',
5354             'uploader_id': 'backuspagemuseum',
5355             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/backuspagemuseum',
5356             'upload_date': '20161008',
5357             'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
5358             'categories': ['Nonprofits & Activism'],
5359             'tags': list,
5360             'like_count': int,
5361             'age_limit': 0,
5362             'playable_in_embed': True,
5363             'thumbnail': 'https://i.ytimg.com/vi_webp/yeWKywCrFtk/maxresdefault.webp',
5364             'channel': 'Backus-Page House Museum',
5365             'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
5366             'live_status': 'not_live',
5367             'view_count': int,
5368             'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
5369             'availability': 'public',
5370             'duration': 59,
5371         },
5372         'params': {
5373             'noplaylist': True,
5374             'skip_download': True,
5375         },
5376     }, {
5377         'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
5378         'only_matching': True,
5379     }]
5380
5381     def _real_extract(self, url):
5382         mobj = self._match_valid_url(url)
5383         video_id = mobj.group('id')
5384         playlist_id = mobj.group('playlist_id')
5385         return self.url_result(
5386             update_url_query('https://www.youtube.com/watch', {
5387                 'v': video_id,
5388                 'list': playlist_id,
5389                 'feature': 'youtu.be',
5390             }), ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
5391
5392
5393 class YoutubeLivestreamEmbedIE(InfoExtractor):
5394     IE_DESC = 'YouTube livestream embeds'
5395     _VALID_URL = r'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
5396     _TESTS = [{
5397         'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
5398         'only_matching': True,
5399     }]
5400
5401     def _real_extract(self, url):
5402         channel_id = self._match_id(url)
5403         return self.url_result(
5404             f'https://www.youtube.com/channel/{channel_id}/live',
5405             ie=YoutubeTabIE.ie_key(), video_id=channel_id)
5406
5407
5408 class YoutubeYtUserIE(InfoExtractor):
5409     IE_DESC = 'YouTube user videos; "ytuser:" prefix'
5410     IE_NAME = 'youtube:user'
5411     _VALID_URL = r'ytuser:(?P<id>.+)'
5412     _TESTS = [{
5413         'url': 'ytuser:phihag',
5414         'only_matching': True,
5415     }]
5416
5417     def _real_extract(self, url):
5418         user_id = self._match_id(url)
5419         return self.url_result(
5420             'https://www.youtube.com/user/%s/videos' % user_id,
5421             ie=YoutubeTabIE.ie_key(), video_id=user_id)
5422
5423
5424 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
5425     IE_NAME = 'youtube:favorites'
5426     IE_DESC = 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
5427     _VALID_URL = r':ytfav(?:ou?rite)?s?'
5428     _LOGIN_REQUIRED = True
5429     _TESTS = [{
5430         'url': ':ytfav',
5431         'only_matching': True,
5432     }, {
5433         'url': ':ytfavorites',
5434         'only_matching': True,
5435     }]
5436
5437     def _real_extract(self, url):
5438         return self.url_result(
5439             'https://www.youtube.com/playlist?list=LL',
5440             ie=YoutubeTabIE.ie_key())
5441
5442
5443 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
5444     IE_DESC = 'YouTube search'
5445     IE_NAME = 'youtube:search'
5446     _SEARCH_KEY = 'ytsearch'
5447     _SEARCH_PARAMS = 'EgIQAQ%3D%3D'  # Videos only
5448     _TESTS = [{
5449         'url': 'ytsearch5:youtube-dl test video',
5450         'playlist_count': 5,
5451         'info_dict': {
5452             'id': 'youtube-dl test video',
5453             'title': 'youtube-dl test video',
5454         }
5455     }]
5456
5457
5458 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
5459     IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
5460     _SEARCH_KEY = 'ytsearchdate'
5461     IE_DESC = 'YouTube search, newest videos first'
5462     _SEARCH_PARAMS = 'CAISAhAB'  # Videos only, sorted by date
5463     _TESTS = [{
5464         'url': 'ytsearchdate5:youtube-dl test video',
5465         'playlist_count': 5,
5466         'info_dict': {
5467             'id': 'youtube-dl test video',
5468             'title': 'youtube-dl test video',
5469         }
5470     }]
5471
5472
5473 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor):
5474     IE_DESC = 'YouTube search URLs with sorting and filter support'
5475     IE_NAME = YoutubeSearchIE.IE_NAME + '_url'
5476     _VALID_URL = r'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
5477     _TESTS = [{
5478         'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
5479         'playlist_mincount': 5,
5480         'info_dict': {
5481             'id': 'youtube-dl test video',
5482             'title': 'youtube-dl test video',
5483         }
5484     }, {
5485         'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
5486         'playlist_mincount': 5,
5487         'info_dict': {
5488             'id': 'python',
5489             'title': 'python',
5490         }
5491
5492     }, {
5493         'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
5494         'only_matching': True,
5495     }]
5496
5497     def _real_extract(self, url):
5498         qs = parse_qs(url)
5499         query = (qs.get('search_query') or qs.get('q'))[0]
5500         return self.playlist_result(self._search_results(query, qs.get('sp', (None,))[0]), query, query)
5501
5502
5503 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor):
5504     IE_DESC = 'YouTube music search URLs with selectable sections (Eg: #songs)'
5505     IE_NAME = 'youtube:music:search_url'
5506     _VALID_URL = r'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
5507     _TESTS = [{
5508         'url': 'https://music.youtube.com/search?q=royalty+free+music',
5509         'playlist_count': 16,
5510         'info_dict': {
5511             'id': 'royalty free music',
5512             'title': 'royalty free music',
5513         }
5514     }, {
5515         'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
5516         'playlist_mincount': 30,
5517         'info_dict': {
5518             'id': 'royalty free music - songs',
5519             'title': 'royalty free music - songs',
5520         },
5521         'params': {'extract_flat': 'in_playlist'}
5522     }, {
5523         'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
5524         'playlist_mincount': 30,
5525         'info_dict': {
5526             'id': 'royalty free music - community playlists',
5527             'title': 'royalty free music - community playlists',
5528         },
5529         'params': {'extract_flat': 'in_playlist'}
5530     }]
5531
5532     _SECTIONS = {
5533         'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
5534         'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
5535         'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
5536         'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
5537         'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
5538         'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
5539     }
5540
5541     def _real_extract(self, url):
5542         qs = parse_qs(url)
5543         query = (qs.get('search_query') or qs.get('q'))[0]
5544         params = qs.get('sp', (None,))[0]
5545         if params:
5546             section = next((k for k, v in self._SECTIONS.items() if v == params), params)
5547         else:
5548             section = compat_urllib_parse_unquote_plus((url.split('#') + [''])[1]).lower()
5549             params = self._SECTIONS.get(section)
5550             if not params:
5551                 section = None
5552         title = join_nonempty(query, section, delim=' - ')
5553         return self.playlist_result(self._search_results(query, params, default_client='web_music'), title, title)
5554
5555
5556 class YoutubeFeedsInfoExtractor(InfoExtractor):
5557     """
5558     Base class for feed extractors
5559     Subclasses must define the _FEED_NAME property.
5560     """
5561     _LOGIN_REQUIRED = True
5562     _TESTS = []
5563
5564     @property
5565     def IE_NAME(self):
5566         return 'youtube:%s' % self._FEED_NAME
5567
5568     def _real_extract(self, url):
5569         return self.url_result(
5570             f'https://www.youtube.com/feed/{self._FEED_NAME}', ie=YoutubeTabIE.ie_key())
5571
5572
5573 class YoutubeWatchLaterIE(InfoExtractor):
5574     IE_NAME = 'youtube:watchlater'
5575     IE_DESC = 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
5576     _VALID_URL = r':ytwatchlater'
5577     _TESTS = [{
5578         'url': ':ytwatchlater',
5579         'only_matching': True,
5580     }]
5581
5582     def _real_extract(self, url):
5583         return self.url_result(
5584             'https://www.youtube.com/playlist?list=WL', ie=YoutubeTabIE.ie_key())
5585
5586
5587 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
5588     IE_DESC = 'YouTube recommended videos; ":ytrec" keyword'
5589     _VALID_URL = r'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
5590     _FEED_NAME = 'recommended'
5591     _LOGIN_REQUIRED = False
5592     _TESTS = [{
5593         'url': ':ytrec',
5594         'only_matching': True,
5595     }, {
5596         'url': ':ytrecommended',
5597         'only_matching': True,
5598     }, {
5599         'url': 'https://youtube.com',
5600         'only_matching': True,
5601     }]
5602
5603
5604 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor):
5605     IE_DESC = 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
5606     _VALID_URL = r':ytsub(?:scription)?s?'
5607     _FEED_NAME = 'subscriptions'
5608     _TESTS = [{
5609         'url': ':ytsubs',
5610         'only_matching': True,
5611     }, {
5612         'url': ':ytsubscriptions',
5613         'only_matching': True,
5614     }]
5615
5616
5617 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
5618     IE_DESC = 'Youtube watch history; ":ythis" keyword (requires cookies)'
5619     _VALID_URL = r':ythis(?:tory)?'
5620     _FEED_NAME = 'history'
5621     _TESTS = [{
5622         'url': ':ythistory',
5623         'only_matching': True,
5624     }]
5625
5626
5627 class YoutubeTruncatedURLIE(InfoExtractor):
5628     IE_NAME = 'youtube:truncated_url'
5629     IE_DESC = False  # Do not list
5630     _VALID_URL = r'''(?x)
5631         (?:https?://)?
5632         (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
5633         (?:watch\?(?:
5634             feature=[a-z_]+|
5635             annotation_id=annotation_[^&]+|
5636             x-yt-cl=[0-9]+|
5637             hl=[^&]*|
5638             t=[0-9]+
5639         )?
5640         |
5641             attribution_link\?a=[^&]+
5642         )
5643         $
5644     '''
5645
5646     _TESTS = [{
5647         'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
5648         'only_matching': True,
5649     }, {
5650         'url': 'https://www.youtube.com/watch?',
5651         'only_matching': True,
5652     }, {
5653         'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
5654         'only_matching': True,
5655     }, {
5656         'url': 'https://www.youtube.com/watch?feature=foo',
5657         'only_matching': True,
5658     }, {
5659         'url': 'https://www.youtube.com/watch?hl=en-GB',
5660         'only_matching': True,
5661     }, {
5662         'url': 'https://www.youtube.com/watch?t=2372',
5663         'only_matching': True,
5664     }]
5665
5666     def _real_extract(self, url):
5667         raise ExtractorError(
5668             'Did you forget to quote the URL? Remember that & is a meta '
5669             'character in most shells, so you want to put the URL in quotes, '
5670             'like  youtube-dl '
5671             '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
5672             ' or simply  youtube-dl BaW_jenozKc  .',
5673             expected=True)
5674
5675
5676 class YoutubeClipIE(InfoExtractor):
5677     IE_NAME = 'youtube:clip'
5678     IE_DESC = False  # Do not list
5679     _VALID_URL = r'https?://(?:www\.)?youtube\.com/clip/'
5680
5681     def _real_extract(self, url):
5682         self.report_warning('YouTube clips are not currently supported. The entire video will be downloaded instead')
5683         return self.url_result(url, 'Generic')
5684
5685
5686 class YoutubeTruncatedIDIE(InfoExtractor):
5687     IE_NAME = 'youtube:truncated_id'
5688     IE_DESC = False  # Do not list
5689     _VALID_URL = r'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
5690
5691     _TESTS = [{
5692         'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
5693         'only_matching': True,
5694     }]
5695
5696     def _real_extract(self, url):
5697         video_id = self._match_id(url)
5698         raise ExtractorError(
5699             'Incomplete YouTube ID %s. URL %s looks truncated.' % (video_id, url),
5700             expected=True)