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