21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
69 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
70 # any clients starting with _ cannot be explicitly requested by the user
73 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
74 'INNERTUBE_CONTEXT': {
77 'clientVersion': '2.20220801.00.00',
80 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
83 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
84 'INNERTUBE_CONTEXT': {
86 'clientName': 'WEB_EMBEDDED_PLAYER',
87 'clientVersion': '1.20220731.00.00',
90 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
93 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
94 'INNERTUBE_HOST': 'music.youtube.com',
95 'INNERTUBE_CONTEXT': {
97 'clientName': 'WEB_REMIX',
98 'clientVersion': '1.20220727.01.00',
101 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
104 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
105 'INNERTUBE_CONTEXT': {
107 'clientName': 'WEB_CREATOR',
108 'clientVersion': '1.20220726.00.00',
111 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
114 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
115 'INNERTUBE_CONTEXT': {
117 'clientName': 'ANDROID',
118 'clientVersion': '17.31.35',
119 'androidSdkVersion': 30,
120 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
123 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
124 'REQUIRE_JS_PLAYER': False
126 'android_embedded': {
127 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
128 'INNERTUBE_CONTEXT': {
130 'clientName': 'ANDROID_EMBEDDED_PLAYER',
131 'clientVersion': '17.31.35',
132 'androidSdkVersion': 30,
133 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
136 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
137 'REQUIRE_JS_PLAYER': False
140 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
141 'INNERTUBE_CONTEXT': {
143 'clientName': 'ANDROID_MUSIC',
144 'clientVersion': '5.16.51',
145 'androidSdkVersion': 30,
146 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
149 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
150 'REQUIRE_JS_PLAYER': False
153 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
154 'INNERTUBE_CONTEXT': {
156 'clientName': 'ANDROID_CREATOR',
157 'clientVersion': '22.30.100',
158 'androidSdkVersion': 30,
159 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
162 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
163 'REQUIRE_JS_PLAYER': False
165 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
166 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
168 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
169 'INNERTUBE_CONTEXT': {
172 'clientVersion': '17.33.2',
173 'deviceModel': 'iPhone14,3',
174 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
177 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
178 'REQUIRE_JS_PLAYER': False
181 'INNERTUBE_CONTEXT': {
183 'clientName': 'IOS_MESSAGES_EXTENSION',
184 'clientVersion': '17.33.2',
185 'deviceModel': 'iPhone14,3',
186 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
189 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
190 'REQUIRE_JS_PLAYER': False
193 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
194 'INNERTUBE_CONTEXT': {
196 'clientName': 'IOS_MUSIC',
197 'clientVersion': '5.21',
198 'deviceModel': 'iPhone14,3',
199 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
202 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
203 'REQUIRE_JS_PLAYER': False
206 'INNERTUBE_CONTEXT': {
208 'clientName': 'IOS_CREATOR',
209 'clientVersion': '22.33.101',
210 'deviceModel': 'iPhone14,3',
211 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
214 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
215 'REQUIRE_JS_PLAYER': False
217 # mweb has 'ultralow' formats
218 # See: https://github.com/yt-dlp/yt-dlp/pull/557
220 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
221 'INNERTUBE_CONTEXT': {
223 'clientName': 'MWEB',
224 'clientVersion': '2.20220801.00.00',
227 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
229 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
230 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
232 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
233 'INNERTUBE_CONTEXT': {
235 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
236 'clientVersion': '2.0',
239 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
244 def _split_innertube_client(client_name
):
245 variant
, *base
= client_name
.rsplit('.', 1)
247 return variant
, base
[0], variant
248 base
, *variant
= client_name
.split('_', 1)
249 return client_name
, base
, variant
[0] if variant
else None
252 def short_client_name(client_name
):
253 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
254 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
257 def build_innertube_clients():
259 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
261 BASE_CLIENTS
= ('android', 'web', 'tv', 'ios', 'mweb')
262 priority
= qualities(BASE_CLIENTS
[::-1])
264 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
265 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
266 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
267 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
268 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
270 _
, base_client
, variant
= _split_innertube_client(client
)
271 ytcfg
['priority'] = 10 * priority(base_client
)
274 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
275 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
276 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
277 embedscreen
['priority'] -= 3
278 elif variant
== 'embedded':
279 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
280 ytcfg
['priority'] -= 2
282 ytcfg
['priority'] -= 3
285 build_innertube_clients()
288 class BadgeType(enum
.Enum
):
289 AVAILABILITY_UNLISTED
= enum
.auto()
290 AVAILABILITY_PRIVATE
= enum
.auto()
291 AVAILABILITY_PUBLIC
= enum
.auto()
292 AVAILABILITY_PREMIUM
= enum
.auto()
293 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
294 LIVE_NOW
= enum
.auto()
297 class YoutubeBaseInfoExtractor(InfoExtractor
):
298 """Provide base functions for Youtube extractors"""
301 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
302 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
303 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
304 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
306 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
308 # _NETRC_MACHINE = 'youtube'
310 # If True it will raise an error if no login info is provided
311 _LOGIN_REQUIRED
= False
314 # invidious-redirect websites
315 r
'(?:www\.)?redirect\.invidious\.io',
316 r
'(?:(?:www|dev)\.)?invidio\.us',
317 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
318 r
'(?:www\.)?invidious\.pussthecat\.org',
319 r
'(?:www\.)?invidious\.zee\.li',
320 r
'(?:www\.)?invidious\.ethibox\.fr',
321 r
'(?:www\.)?iv\.ggtyler\.dev',
322 r
'(?:www\.)?inv\.vern\.i2p',
323 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
324 r
'(?:www\.)?inv\.riverside\.rocks',
325 r
'(?:www\.)?invidious\.silur\.me',
326 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
327 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
328 r
'(?:www\.)?invidious\.slipfox\.xyz',
329 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
330 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
331 r
'(?:www\.)?invidious\.tiekoetter\.com',
332 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
333 r
'(?:www\.)?invidious\.nerdvpn\.de',
334 r
'(?:www\.)?invidious\.weblibre\.org',
335 r
'(?:www\.)?inv\.odyssey346\.dev',
336 r
'(?:www\.)?invidious\.dhusch\.de',
337 r
'(?:www\.)?iv\.melmac\.space',
338 r
'(?:www\.)?watch\.thekitty\.zone',
339 r
'(?:www\.)?invidious\.privacydev\.net',
340 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
341 r
'(?:www\.)?invidious\.drivet\.xyz',
342 r
'(?:www\.)?vid\.priv\.au',
343 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
344 r
'(?:www\.)?inv\.vern\.cc',
345 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
346 r
'(?:www\.)?invidious\.sethforprivacy\.com',
347 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
348 r
'(?:www\.)?yt\.artemislena\.eu',
349 r
'(?:www\.)?invidious\.flokinet\.to',
350 r
'(?:www\.)?invidious\.baczek\.me',
351 r
'(?:www\.)?y\.com\.sb',
352 r
'(?:www\.)?invidious\.epicsite\.xyz',
353 r
'(?:www\.)?invidious\.lidarshield\.cloud',
354 r
'(?:www\.)?yt\.funami\.tech',
355 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
356 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
357 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
358 # youtube-dl invidious instances list
359 r
'(?:(?:www|no)\.)?invidiou\.sh',
360 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
361 r
'(?:www\.)?invidious\.kabi\.tk',
362 r
'(?:www\.)?invidious\.mastodon\.host',
363 r
'(?:www\.)?invidious\.zapashcanon\.fr',
364 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
365 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
366 r
'(?:www\.)?invidious\.himiko\.cloud',
367 r
'(?:www\.)?invidious\.reallyancient\.tech',
368 r
'(?:www\.)?invidious\.tube',
369 r
'(?:www\.)?invidiou\.site',
370 r
'(?:www\.)?invidious\.site',
371 r
'(?:www\.)?invidious\.xyz',
372 r
'(?:www\.)?invidious\.nixnet\.xyz',
373 r
'(?:www\.)?invidious\.048596\.xyz',
374 r
'(?:www\.)?invidious\.drycat\.fr',
375 r
'(?:www\.)?inv\.skyn3t\.in',
376 r
'(?:www\.)?tube\.poal\.co',
377 r
'(?:www\.)?tube\.connect\.cafe',
378 r
'(?:www\.)?vid\.wxzm\.sx',
379 r
'(?:www\.)?vid\.mint\.lgbt',
380 r
'(?:www\.)?vid\.puffyan\.us',
381 r
'(?:www\.)?yewtu\.be',
382 r
'(?:www\.)?yt\.elukerio\.org',
383 r
'(?:www\.)?yt\.lelux\.fi',
384 r
'(?:www\.)?invidious\.ggc-project\.de',
385 r
'(?:www\.)?yt\.maisputain\.ovh',
386 r
'(?:www\.)?ytprivate\.com',
387 r
'(?:www\.)?invidious\.13ad\.de',
388 r
'(?:www\.)?invidious\.toot\.koeln',
389 r
'(?:www\.)?invidious\.fdn\.fr',
390 r
'(?:www\.)?watch\.nettohikari\.com',
391 r
'(?:www\.)?invidious\.namazso\.eu',
392 r
'(?:www\.)?invidious\.silkky\.cloud',
393 r
'(?:www\.)?invidious\.exonip\.de',
394 r
'(?:www\.)?invidious\.riverside\.rocks',
395 r
'(?:www\.)?invidious\.blamefran\.net',
396 r
'(?:www\.)?invidious\.moomoo\.de',
397 r
'(?:www\.)?ytb\.trom\.tf',
398 r
'(?:www\.)?yt\.cyberhost\.uk',
399 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
400 r
'(?:www\.)?qklhadlycap4cnod\.onion',
401 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
402 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
403 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
404 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
405 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
406 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
407 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
408 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
409 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
410 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
411 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
412 r
'(?:www\.)?piped\.kavin\.rocks',
413 r
'(?:www\.)?piped\.tokhmi\.xyz',
414 r
'(?:www\.)?piped\.syncpundit\.io',
415 r
'(?:www\.)?piped\.mha\.fi',
416 r
'(?:www\.)?watch\.whatever\.social',
417 r
'(?:www\.)?piped\.garudalinux\.org',
418 r
'(?:www\.)?piped\.rivo\.lol',
419 r
'(?:www\.)?piped-libre\.kavin\.rocks',
420 r
'(?:www\.)?yt\.jae\.fi',
421 r
'(?:www\.)?piped\.mint\.lgbt',
423 r
'(?:www\.)?piped\.esmailelbob\.xyz',
424 r
'(?:www\.)?piped\.projectsegfau\.lt',
425 r
'(?:www\.)?piped\.privacydev\.net',
426 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
427 r
'(?:www\.)?piped\.smnz\.de',
428 r
'(?:www\.)?piped\.adminforge\.de',
429 r
'(?:www\.)?watch\.whatevertinfoil\.de',
430 r
'(?:www\.)?piped\.qdi\.fi',
431 r
'(?:www\.)?piped\.video',
432 r
'(?:www\.)?piped\.aeong\.one',
433 r
'(?:www\.)?piped\.moomoo\.me',
434 r
'(?:www\.)?piped\.chauvet\.pro',
435 r
'(?:www\.)?watch\.leptons\.xyz',
436 r
'(?:www\.)?pd\.vern\.cc',
437 r
'(?:www\.)?piped\.hostux\.net',
438 r
'(?:www\.)?piped\.lunar\.icu',
439 # Hyperpipe instances from https://hyperpipe.codeberg.page/
440 r
'(?:www\.)?hyperpipe\.surge\.sh',
441 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
442 r
'(?:www\.)?listen\.whatever\.social',
443 r
'(?:www\.)?music\.adminforge\.de',
446 # extracted from account/account_menu ep
447 # XXX: These are the supported YouTube UI and API languages,
448 # which is slightly different from languages supported for translation in YouTube studio
449 _SUPPORTED_LANG_CODES
= [
450 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
451 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
452 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
453 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
454 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
455 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
458 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
460 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
461 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
463 def ucid_or_none(self
, ucid
):
464 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
466 def handle_or_none(self
, handle
):
467 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
469 def handle_from_url(self
, url
):
470 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
471 url
, 'channel handle', default
=None)
473 def ucid_from_url(self
, url
):
474 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
475 url
, 'channel id', default
=None)
477 @functools.cached_property
478 def _preferred_lang(self
):
480 Returns a language code supported by YouTube for the user preferred language.
481 Returns None if no preferred language set.
483 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
484 if not preferred_lang
:
486 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
487 raise ExtractorError(
488 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
490 elif preferred_lang
!= 'en':
492 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
493 return preferred_lang
495 def _initialize_consent(self
):
496 cookies
= self
._get
_cookies
('https://www.youtube.com/')
497 if cookies
.get('__Secure-3PSID'):
500 consent
= cookies
.get('CONSENT')
502 if 'YES' in consent
.value
:
504 consent_id
= self
._search
_regex
(
505 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
507 consent_id
= random
.randint(100, 999)
508 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
510 def _initialize_pref(self
):
511 cookies
= self
._get
_cookies
('https://www.youtube.com/')
512 pref_cookie
= cookies
.get('PREF')
516 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
518 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
519 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
520 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
522 def _real_initialize(self
):
523 self
._initialize
_pref
()
524 self
._initialize
_consent
()
525 self
._check
_login
_required
()
527 def _check_login_required(self
):
528 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
529 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
531 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
532 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
534 def _get_default_ytcfg(self, client='web'):
535 return copy.deepcopy(INNERTUBE_CLIENTS[client])
537 def _get_innertube_host(self, client='web'):
538 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
540 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
541 # try_get but with fallback to default ytcfg client values when present
542 _func = lambda y: try_get(y, getter, expected_type)
543 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
545 def _extract_client_name(self, ytcfg, default_client='web'):
546 return self._ytcfg_get_safe(
547 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
548 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
550 def _extract_client_version(self, ytcfg, default_client='web'):
551 return self._ytcfg_get_safe(
552 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
553 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
555 def _select_api_hostname(self, req_api_hostname, default_client=None):
556 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
557 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
559 def _extract_api_key(self, ytcfg=None, default_client='web'):
560 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
562 def _extract_context(self, ytcfg=None, default_client='web'):
564 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
565 # Enforce language and tz for extraction
566 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
567 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
572 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
573 time_now = round(time.time())
574 if self._SAPISID is None:
575 yt_cookies = self._get_cookies('https://www.youtube.com')
576 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
577 # See: https://github.com/yt-dlp/yt-dlp/issues/393
578 sapisid_cookie = dict_get(
579 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
580 if sapisid_cookie and sapisid_cookie.value:
581 self._SAPISID = sapisid_cookie.value
582 self.write_debug('Extracted SAPISID cookie')
583 # SAPISID cookie is required if not already present
584 if not yt_cookies.get('SAPISID'):
585 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
587 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
589 self._SAPISID = False
590 if not self._SAPISID:
592 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
593 sapisidhash = hashlib.sha1(
594 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
595 return f'SAPISIDHASH {time_now}_{sapisidhash}'
597 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
598 note='Downloading API JSON', errnote='Unable to download API page',
599 context=None, api_key=None, api_hostname=None, default_client='web'):
601 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
603 real_headers = self.generate_api_headers(default_client=default_client)
604 real_headers.update({'content-type': 'application/json'})
606 real_headers.update(headers)
607 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
608 or api_key or self._extract_api_key(default_client=default_client))
609 return self._download_json(
610 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
611 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
612 data=json.dumps(data).encode('utf8'), headers=real_headers,
613 query={'key': api_key, 'prettyPrint': 'false'})
615 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
616 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
619 def _extract_session_index(*data):
621 Index of current account in account list.
622 See: https://github.com/yt-dlp/yt-dlp/pull/519
625 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
626 if session_index is not None:
630 def _extract_identity_token(self, ytcfg=None, webpage=None):
632 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
636 return self._search_regex(
637 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
638 'identity token
', default=None, fatal=False)
641 def _extract_account_syncid(*args):
643 Extract syncId required to download private playlists of secondary channels
644 @params response and/or ytcfg
647 # ytcfg includes channel_syncid if on secondary channel
648 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
652 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
653 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
654 if len(sync_ids) >= 2 and sync_ids[1]:
655 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
656 # and just "user_syncid||" for primary channel. We only want the channel_syncid
660 def _extract_visitor_data(*args):
662 Extracts visitorData from an API response or ytcfg
663 Appears to be used to track session state
666 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
669 @functools.cached_property
670 def is_authenticated(self):
671 return bool(self._generate_sapisidhash_header())
673 def extract_ytcfg(self, video_id, webpage):
676 return self._parse_json(
678 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
679 default='{}'), video_id, fatal=False) or {}
681 def generate_api_headers(
682 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
683 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
685 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
687 'X-YouTube-Client-Name': str(
688 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
689 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
691 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
692 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
693 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
694 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
696 if session_index
is None:
697 session_index
= self
._extract
_session
_index
(ytcfg
)
698 if account_syncid
or session_index
is not None:
699 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
701 auth
= self
._generate
_sapisidhash
_header
(origin
)
703 headers
['Authorization'] = auth
704 headers
['X-Origin'] = origin
705 return filter_dict(headers
)
707 def _download_ytcfg(self
, client
, video_id
):
709 'web': 'https://www.youtube.com',
710 'web_music': 'https://music.youtube.com',
711 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
715 webpage
= self
._download
_webpage
(
716 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
717 return self
.extract_ytcfg(video_id
, webpage
) or {}
720 def _build_api_continuation_query(continuation
, ctp
=None):
722 'continuation': continuation
724 # TODO: Inconsistency with clickTrackingParams.
725 # Currently we have a fixed ctp contained within context (from ytcfg)
726 # and a ctp in root query for continuation.
728 query
['clickTracking'] = {'clickTrackingParams': ctp}
732 def _extract_next_continuation_data(cls
, renderer
):
733 next_continuation
= try_get(
734 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
735 lambda x
: x
['continuation']['reloadContinuationData']), dict)
736 if not next_continuation
:
738 continuation
= next_continuation
.get('continuation')
741 ctp
= next_continuation
.get('clickTrackingParams')
742 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
745 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
746 if isinstance(continuation_ep
, dict):
747 continuation
= try_get(
748 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
751 ctp
= continuation_ep
.get('clickTrackingParams')
752 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
755 def _extract_continuation(cls
, renderer
):
756 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
757 if next_continuation
:
758 return next_continuation
760 return traverse_obj(renderer
, (
761 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
762 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
763 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
766 def _extract_alerts(cls
, data
):
767 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
768 if not isinstance(alert_dict
, dict):
770 for alert
in alert_dict
.values():
771 alert_type
= alert
.get('type')
774 message
= cls
._get
_text
(alert
, 'text')
776 yield alert_type
, message
778 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
779 errors
, warnings
= [], []
780 for alert_type
, alert_message
in alerts
:
781 if alert_type
.lower() == 'error' and fatal
:
782 errors
.append([alert_type
, alert_message
])
783 elif alert_message
not in self
._IGNORED
_WARNINGS
:
784 warnings
.append([alert_type
, alert_message
])
786 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
787 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
789 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
791 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
792 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
794 def _extract_badges(self
, renderer
: dict):
796 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
797 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
798 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
802 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
803 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
804 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
808 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
809 'private': BadgeType
.AVAILABILITY_PRIVATE
,
810 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
811 'live': BadgeType
.LIVE_NOW
,
812 'premium': BadgeType
.AVAILABILITY_PREMIUM
816 for badge
in traverse_obj(renderer
, ('badges', ..., 'metadataBadgeRenderer')):
818 privacy_icon_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
819 or badge_style_map
.get(traverse_obj(badge
, 'style'))
822 badges
.append({'type': badge_type}
)
825 # fallback, won't work in some languages
826 label
= traverse_obj(badge
, 'label', expected_type
=str, default
='')
827 for match
, label_badge_type
in label_map
.items():
828 if match
in label
.lower():
829 badges
.append({'type': badge_type}
)
835 def _has_badge(badges
, badge_type
):
836 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
839 def _get_text(data
, *path_list
, max_runs
=None):
840 for path
in path_list
or [None]:
844 obj
= traverse_obj(data
, path
, default
=[])
845 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
848 text
= try_get(item
, lambda x
: x
['simpleText'], str)
851 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
852 if not runs
and isinstance(item
, list):
855 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
856 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
860 def _get_count(self
, data
, *path_list
):
861 count_text
= self
._get
_text
(data
, *path_list
) or ''
862 count
= parse_count(count_text
)
865 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
869 def _extract_thumbnails(data
, *path_list
):
871 Extract thumbnails from thumbnails dict
872 @param path_list: path list to level that contains 'thumbnails' key
875 for path
in path_list
or [()]:
876 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
877 thumbnail_url
= url_or_none(thumbnail
.get('url'))
878 if not thumbnail_url
:
880 # Sometimes youtube gives a wrong thumbnail URL. See:
881 # https://github.com/yt-dlp/yt-dlp/issues/233
882 # https://github.com/ytdl-org/youtube-dl/issues/28023
883 if 'maxresdefault' in thumbnail_url
:
884 thumbnail_url
= thumbnail_url
.split('?')[0]
886 'url': thumbnail_url
,
887 'height': int_or_none(thumbnail
.get('height')),
888 'width': int_or_none(thumbnail
.get('width')),
893 def extract_relative_time(relative_time_text
):
895 Extracts a relative time from string and converts to dt object
896 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
899 # XXX: this could be moved to a general function in utils.py
900 # The relative time text strings are roughly the same as what
901 # Javascript's Intl.RelativeTimeFormat function generates.
902 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
904 r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
907 start
= mobj
.group('start')
909 return datetime_from_str(start
)
911 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
915 def _parse_time_text(self
, text
):
918 dt
= self
.extract_relative_time(text
)
920 if isinstance(dt
, datetime
.datetime
):
921 timestamp
= calendar
.timegm(dt
.timetuple())
923 if timestamp
is None:
925 unified_timestamp(text
) or unified_timestamp(
927 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
928 text
.lower(), 'time text', default
=None)))
930 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
932 f
'Cannot parse localized time text "{text}"', only_once
=True)
935 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
936 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
937 default_client
='web'):
938 for retry
in self
.RetryManager():
940 response
= self
._call
_api
(
941 ep
=ep
, fatal
=True, headers
=headers
,
942 video_id
=item_id
, query
=query
, note
=note
,
943 context
=self
._extract
_context
(ytcfg
, default_client
),
944 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
945 api_hostname
=api_hostname
, default_client
=default_client
)
946 except ExtractorError
as e
:
947 if not isinstance(e
.cause
, network_exceptions
):
948 return self
._error
_or
_warning
(e
, fatal
=fatal
)
949 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
953 first_bytes
= e
.cause
.read(512)
954 if not is_html(first_bytes
):
957 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
958 lambda x
: x
['error']['message'], str)
960 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
961 # Downloading page may result in intermittent 5xx HTTP error
962 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
963 # We also want to catch all other network exceptions since errors in later pages can be troublesome
964 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
965 if e
.cause
.code
not in (403, 429):
968 return self
._error
_or
_warning
(e
, fatal
=fatal
)
971 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
972 except ExtractorError
as e
:
973 # YouTube servers may return errors we want to retry on in a 200 OK response
974 # See: https://github.com/yt-dlp/yt-dlp/issues/839
975 if 'unknown error' in e
.msg
.lower():
978 return self
._error
_or
_warning
(e
, fatal
=fatal
)
979 # Youtube sometimes sends incomplete data
980 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
981 if not traverse_obj(response
, *variadic(check_get_keys
)):
982 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
988 def is_music_url(url
):
989 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
991 def _extract_video(self
, renderer
):
992 video_id
= renderer
.get('videoId')
994 reel_header_renderer
= traverse_obj(renderer
, (
995 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
996 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
998 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
999 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1001 duration
= int_or_none(renderer
.get('lengthSeconds'))
1002 if duration
is None:
1003 duration
= parse_duration(self
._get
_text
(
1004 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1005 if duration
is None:
1006 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1007 duration
= parse_duration(self
._search
_regex
(
1008 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1009 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1010 video_id
, default
=None, group
='duration'))
1012 channel_id
= traverse_obj(
1013 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1014 expected_type
=str, get_all
=False)
1016 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1018 channel_id
= self
.ucid_or_none(channel_id
)
1020 overlay_style
= traverse_obj(
1021 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1022 get_all
=False, expected_type
=str)
1023 badges
= self
._extract
_badges
(renderer
)
1025 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1026 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1027 expected_type
=str)) or ''
1028 url
= f
'https://www.youtube.com/watch?v={video_id}'
1029 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1030 url
= f
'https://www.youtube.com/shorts/{video_id}'
1032 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1033 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1034 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1037 'is_upcoming' if scheduled_timestamp
is not None
1038 else 'was_live' if 'streamed' in time_text
.lower()
1039 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1042 # videoInfo is a string like '50K views • 10 years ago'.
1043 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1044 view_count
= (0 if 'no views' in view_count_text
.lower()
1045 else self
._get
_count
({'simpleText': view_count_text}
))
1046 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1048 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1049 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1051 channel_handle
= traverse_obj(renderer
, (
1052 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1053 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1054 expected_type
=self
.handle_from_url
, get_all
=False)
1057 'ie_key': YoutubeIE
.ie_key(),
1061 'description': description
,
1062 'duration': duration
,
1063 'channel_id': channel_id
,
1065 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1066 'uploader': channel
,
1067 'uploader_id': channel_handle
,
1068 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1069 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1070 'timestamp': (self
._parse
_time
_text
(time_text
)
1071 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1073 'release_timestamp': scheduled_timestamp
,
1075 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1076 else self
._availability
(
1077 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1078 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1079 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1080 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1081 view_count_field
: view_count
,
1082 'live_status': live_status
1086 class YoutubeIE(YoutubeBaseInfoExtractor
):
1088 _VALID_URL
= r
"""(?x)^
1090 (?:https?://|//) # http(s):// or protocol-independent URL
1091 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1092 (?:www\.)?deturl\.com/www\.youtube\.com|
1093 (?:www\.)?pwnyoutube\.com|
1094 (?:www\.)?hooktube\.com|
1095 (?:www\.)?yourepeat\.com|
1096 tube\.majestyc\.net|
1098 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1099 (?:.*?\#/)? # handle anchor (#/) redirect urls
1100 (?: # the various things that can precede the ID:
1101 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1102 |(?: # or the v= param in all its forms
1103 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1104 (?:\?|\#!?) # the params delimiter ? or # or #!
1105 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1110 youtu\.be| # just youtu.be/xxxx
1111 vid\.plus| # or vid.plus/xxxx
1112 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1115 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1117 )? # all until now is optional -> you can pass the naked ID
1118 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1119 (?(1).+)? # if we found the ID, everything can follow
1121 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1126 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1134 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1135 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1137 # https://wordpress.org/plugins/lazy-load-for-videos/
1139 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1140 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1142 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1145 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1146 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$',
1147 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1150 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1151 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1152 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1153 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1154 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1155 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1156 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1157 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1158 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1159 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1160 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1161 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1162 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1163 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1164 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1165 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1166 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1167 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1171 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1172 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1173 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1174 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1175 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1176 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1177 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1179 # Apple HTTP Live Streaming
1180 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1181 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1182 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1183 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1184 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1185 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1186 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1187 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1190 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1191 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1192 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1193 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1194 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1195 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1196 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1197 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1198 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1199 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1200 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1201 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1204 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1205 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1206 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1207 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1208 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1209 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1210 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1213 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1214 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1215 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1216 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1217 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1218 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1219 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1220 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1221 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1222 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1223 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1224 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1225 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1226 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1227 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1228 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1229 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1230 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1231 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1232 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1233 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1234 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1237 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1238 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1240 # Dash webm audio with opus inside
1241 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1242 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1243 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1246 '_rtmp': {'protocol': 'rtmp'},
1248 # av01 video only formats sometimes served with "unknown" codecs
1249 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1250 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1251 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1252 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1253 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1254 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1255 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1256 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1258 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1265 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1267 'id': 'BaW_jenozKc',
1269 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1270 'channel': 'Philipp Hagemeister',
1271 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1272 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1273 'upload_date': '20121002',
1274 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1275 'categories': ['Science & Technology'],
1276 'tags': ['youtube-dl'],
1280 'availability': 'public',
1281 'playable_in_embed': True,
1282 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1283 'live_status': 'not_live',
1287 'comment_count': int,
1288 'channel_follower_count': int,
1289 'uploader': 'Philipp Hagemeister',
1290 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1291 'uploader_id': '@PhilippHagemeister',
1292 'heatmap': 'count:100',
1296 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1297 'note': 'Embed-only video (#1746)',
1299 'id': 'yZIXLfi8CZQ',
1301 'upload_date': '20120608',
1302 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1303 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1306 'skip': 'Private video',
1309 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1310 'note': 'Use the first video ID in the URL',
1312 'id': 'BaW_jenozKc',
1314 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1315 'channel': 'Philipp Hagemeister',
1316 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1317 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1318 'upload_date': '20121002',
1319 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1320 'categories': ['Science & Technology'],
1321 'tags': ['youtube-dl'],
1325 'availability': 'public',
1326 'playable_in_embed': True,
1327 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1328 'live_status': 'not_live',
1330 'comment_count': int,
1331 'channel_follower_count': int,
1332 'uploader': 'Philipp Hagemeister',
1333 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1334 'uploader_id': '@PhilippHagemeister',
1337 'skip_download': True,
1341 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1342 'note': '256k DASH audio (format 141) via DASH manifest',
1344 'id': 'a9LDPn-MO4I',
1346 'upload_date': '20121002',
1348 'title': 'UHDTV TEST 8K VIDEO.mp4'
1351 'youtube_include_dash_manifest': True,
1354 'skip': 'format 141 not served anymore',
1356 # DASH manifest with encrypted signature
1358 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1360 'id': 'IB3lcPjvWLA',
1362 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1363 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1365 'upload_date': '20131011',
1368 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1369 'playable_in_embed': True,
1370 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1372 'track': 'The Spark',
1373 'live_status': 'not_live',
1374 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1375 'channel': 'Afrojack',
1377 'availability': 'public',
1378 'categories': ['Music'],
1380 'alt_title': 'The Spark',
1381 'channel_follower_count': int,
1382 'uploader': 'Afrojack',
1383 'uploader_url': 'https://www.youtube.com/@Afrojack',
1384 'uploader_id': '@Afrojack',
1387 'youtube_include_dash_manifest': True,
1388 'format': '141/bestaudio[ext=m4a]',
1391 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1393 'note': 'Embed allowed age-gate video',
1394 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1396 'id': 'HtVdAasjOgU',
1398 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1399 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1401 'upload_date': '20140605',
1403 'categories': ['Gaming'],
1404 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1405 'availability': 'needs_auth',
1406 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1408 'channel': 'The Witcher',
1409 'live_status': 'not_live',
1411 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1412 'playable_in_embed': True,
1414 'channel_follower_count': int,
1415 'uploader': 'The Witcher',
1416 'uploader_url': 'https://www.youtube.com/@thewitcher',
1417 'uploader_id': '@thewitcher',
1421 'note': 'Age-gate video with embed allowed in public site',
1422 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1424 'id': 'HsUATh_Nc2U',
1426 'title': 'Godzilla 2 (Official Video)',
1427 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1428 'upload_date': '20200408',
1430 'availability': 'needs_auth',
1431 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1432 'channel': 'FlyingKitty',
1433 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1435 'categories': ['Entertainment'],
1436 'live_status': 'not_live',
1437 'tags': ['Flyingkitty', 'godzilla 2'],
1438 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1441 'playable_in_embed': True,
1442 'channel_follower_count': int,
1443 'uploader': 'FlyingKitty',
1444 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1445 'uploader_id': '@FlyingKitty900',
1446 'comment_count': int,
1450 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1451 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1453 'id': 'Tq92D6wQ1mg',
1454 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1456 'upload_date': '20191228',
1457 'description': 'md5:17eccca93a786d51bc67646756894066',
1460 'availability': 'needs_auth',
1461 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1463 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1464 'channel': 'Projekt Melody',
1465 'live_status': 'not_live',
1466 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1467 'playable_in_embed': True,
1468 'categories': ['Entertainment'],
1470 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1471 'comment_count': int,
1472 'channel_follower_count': int,
1473 'uploader': 'Projekt Melody',
1474 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1475 'uploader_id': '@ProjektMelody',
1479 'note': 'Non-Agegated non-embeddable video',
1480 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1482 'id': 'MeJVWBSsPAY',
1484 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1485 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1486 'upload_date': '20130730',
1487 'track': 'Such mich find mich',
1489 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1491 'playable_in_embed': False,
1492 'creator': 'OOMPH!',
1493 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1495 'alt_title': 'Such mich find mich',
1497 'channel': 'Herr Lurik',
1498 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1499 'categories': ['Music'],
1500 'availability': 'public',
1501 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1502 'live_status': 'not_live',
1504 'channel_follower_count': int,
1505 'uploader': 'Herr Lurik',
1506 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1507 'uploader_id': '@HerrLurik',
1511 'note': 'Non-bypassable age-gated video',
1512 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1513 'only_matching': True,
1515 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1516 # YouTube Red ad is not captured for creator
1518 'url': '__2ABJjxzNo',
1520 'id': '__2ABJjxzNo',
1523 'upload_date': '20100430',
1524 'creator': 'deadmau5',
1525 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1526 'title': 'Deadmau5 - Some Chords (HD)',
1527 'alt_title': 'Some Chords',
1528 'availability': 'public',
1530 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1532 'live_status': 'not_live',
1533 'channel': 'deadmau5',
1534 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1536 'track': 'Some Chords',
1537 'artist': 'deadmau5',
1538 'playable_in_embed': True,
1540 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1541 'categories': ['Music'],
1542 'album': 'Some Chords',
1543 'channel_follower_count': int,
1544 'uploader': 'deadmau5',
1545 'uploader_url': 'https://www.youtube.com/@deadmau5',
1546 'uploader_id': '@deadmau5',
1548 'expected_warnings': [
1549 'DASH manifest missing',
1552 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1554 'url': 'lqQg6PlCWgI',
1556 'id': 'lqQg6PlCWgI',
1559 'upload_date': '20150827',
1560 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1561 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1563 'release_timestamp': 1343767800,
1564 'playable_in_embed': True,
1565 'categories': ['Sports'],
1566 'release_date': '20120731',
1567 'channel': 'Olympics',
1568 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1569 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1570 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1572 'availability': 'public',
1573 'live_status': 'was_live',
1575 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1576 'channel_follower_count': int,
1577 'uploader': 'Olympics',
1578 'uploader_url': 'https://www.youtube.com/@Olympics',
1579 'uploader_id': '@Olympics',
1582 'skip_download': 'requires avconv',
1587 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1589 'id': '_b-2C3KPAM0',
1591 'stretched_ratio': 16 / 9.,
1593 'upload_date': '20110310',
1594 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1595 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1596 'playable_in_embed': True,
1600 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1601 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1602 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1604 'categories': ['People & Blogs'],
1606 'live_status': 'not_live',
1607 'availability': 'unlisted',
1608 'comment_count': int,
1609 'channel_follower_count': int,
1611 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1612 'uploader_id': '@AllenMeow',
1615 # url_encoded_fmt_stream_map is empty string
1617 'url': 'qEJwOuvDf7I',
1619 'id': 'qEJwOuvDf7I',
1621 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1623 'upload_date': '20150404',
1626 'skip_download': 'requires avconv',
1628 'skip': 'This live event has ended.',
1630 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1632 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1634 'id': 'FIl7x6_3R5Y',
1636 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1637 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1639 'upload_date': '20150625',
1640 'formats': 'mincount:31',
1642 'skip': 'not actual anymore',
1644 # DASH manifest with segment_list
1646 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1647 'md5': '8ce563a1d667b599d21064e982ab9e31',
1649 'id': 'CsmdDsKjzN8',
1651 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1652 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1653 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1656 'youtube_include_dash_manifest': True,
1657 'format': '135', # bestvideo
1659 'skip': 'This live event has ended.',
1662 # Multifeed videos (multiple cameras), URL can be of any Camera
1663 # TODO: fix multifeed titles
1664 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1666 'id': 'zaPI8MvL8pg',
1667 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1668 'description': 'md5:563ccbc698b39298481ca3c571169519',
1672 'id': 'j5yGuxZ8lLU',
1674 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1675 'description': 'md5:563ccbc698b39298481ca3c571169519',
1677 'channel_follower_count': int,
1678 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1679 'availability': 'public',
1680 'playable_in_embed': True,
1681 'upload_date': '20131105',
1682 'categories': ['Gaming'],
1683 'live_status': 'was_live',
1685 'release_timestamp': 1383701910,
1686 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1687 'comment_count': int,
1690 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1691 'channel': 'WiiLikeToPlay',
1693 'release_date': '20131106',
1694 'uploader': 'WiiLikeToPlay',
1695 'uploader_id': '@WLTP',
1696 'uploader_url': 'https://www.youtube.com/@WLTP',
1700 'id': 'zaPI8MvL8pg',
1702 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1703 'availability': 'public',
1704 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1705 'channel': 'WiiLikeToPlay',
1706 'channel_follower_count': int,
1707 'description': 'md5:563ccbc698b39298481ca3c571169519',
1712 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1713 'release_timestamp': 1383701915,
1714 'comment_count': int,
1715 'upload_date': '20131105',
1716 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1717 'release_date': '20131106',
1718 'playable_in_embed': True,
1719 'live_status': 'was_live',
1720 'categories': ['Gaming'],
1722 'uploader': 'WiiLikeToPlay',
1723 'uploader_id': '@WLTP',
1724 'uploader_url': 'https://www.youtube.com/@WLTP',
1728 'id': 'R7r3vfO7Hao',
1730 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1731 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1732 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1734 'availability': 'public',
1735 'playable_in_embed': True,
1736 'upload_date': '20131105',
1737 'description': 'md5:563ccbc698b39298481ca3c571169519',
1738 'channel_follower_count': int,
1740 'release_date': '20131106',
1741 'comment_count': int,
1742 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1743 'channel': 'WiiLikeToPlay',
1744 'categories': ['Gaming'],
1745 'release_timestamp': 1383701914,
1746 'live_status': 'was_live',
1750 'uploader': 'WiiLikeToPlay',
1751 'uploader_id': '@WLTP',
1752 'uploader_url': 'https://www.youtube.com/@WLTP',
1755 'params': {'skip_download': True},
1758 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1759 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1761 'id': 'gVfLd0zydlo',
1762 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1764 'playlist_count': 2,
1765 'skip': 'Not multifeed anymore',
1768 'url': 'https://vid.plus/FlRa-iH7PGw',
1769 'only_matching': True,
1772 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1773 'only_matching': True,
1776 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1777 # Also tests cut-off URL expansion in video description (see
1778 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1779 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1780 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1782 'id': 'lsguqyKfVQg',
1784 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1785 'alt_title': 'Dark Walk',
1786 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1788 'upload_date': '20151119',
1789 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1790 'track': 'Dark Walk',
1791 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1792 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1793 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1794 'categories': ['Film & Animation'],
1796 'live_status': 'not_live',
1797 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1798 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1800 'availability': 'public',
1801 'channel': 'IronSoulElf',
1802 'playable_in_embed': True,
1805 'channel_follower_count': int
1808 'skip_download': True,
1812 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1813 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1814 'only_matching': True,
1817 # Video with yt:stretch=17:0
1818 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1820 'id': 'Q39EVAstoRM',
1822 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1823 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1824 'upload_date': '20151107',
1827 'skip_download': True,
1829 'skip': 'This video does not exist.',
1832 # Video with incomplete 'yt:stretch=16:'
1833 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1834 'only_matching': True,
1837 # Video licensed under Creative Commons
1838 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1840 'id': 'M4gD1WSo5mA',
1842 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1843 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1845 'upload_date': '20150128',
1846 'license': 'Creative Commons Attribution license (reuse allowed)',
1847 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1848 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1851 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1852 'channel': 'The Berkman Klein Center for Internet & Society',
1853 'availability': 'public',
1855 'categories': ['Education'],
1856 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1857 'live_status': 'not_live',
1858 'playable_in_embed': True,
1859 'channel_follower_count': int,
1861 'uploader': 'The Berkman Klein Center for Internet & Society',
1862 'uploader_id': '@BKCHarvard',
1863 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1866 'skip_download': True,
1870 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1872 'id': 'eQcmzGIKrzg',
1874 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1875 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1877 'upload_date': '20151120',
1878 'license': 'Creative Commons Attribution license (reuse allowed)',
1879 'playable_in_embed': True,
1882 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1884 'availability': 'public',
1885 'categories': ['News & Politics'],
1886 'channel': 'Bernie Sanders',
1887 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1889 'live_status': 'not_live',
1890 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1891 'comment_count': int,
1892 'channel_follower_count': int,
1894 'uploader': 'Bernie Sanders',
1895 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1896 'uploader_id': '@BernieSanders',
1899 'skip_download': True,
1903 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1904 'only_matching': True,
1907 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1908 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1909 'only_matching': True,
1912 # Rental video preview
1913 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1915 'id': 'uGpuVWrhIzE',
1917 'title': 'Piku - Trailer',
1918 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1919 'upload_date': '20150811',
1920 'license': 'Standard YouTube License',
1923 'skip_download': True,
1925 'skip': 'This video is not available.',
1928 # YouTube Red video with episode data
1929 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1931 'id': 'iqKdEhx-dD4',
1933 'title': 'Isolation - Mind Field (Ep 1)',
1934 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1936 'upload_date': '20170118',
1937 'series': 'Mind Field',
1939 'episode_number': 1,
1940 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1943 'availability': 'public',
1945 'channel': 'Vsauce',
1946 'episode': 'Episode 1',
1947 'categories': ['Entertainment'],
1948 'season': 'Season 1',
1949 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1950 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1952 'playable_in_embed': True,
1953 'live_status': 'not_live',
1954 'channel_follower_count': int,
1955 'uploader': 'Vsauce',
1956 'uploader_url': 'https://www.youtube.com/@Vsauce',
1957 'uploader_id': '@Vsauce',
1960 'skip_download': True,
1962 'expected_warnings': [
1963 'Skipping DASH manifest',
1967 # The following content has been identified by the YouTube community
1968 # as inappropriate or offensive to some audiences.
1969 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1971 'id': '6SJNVb0GnPI',
1973 'title': 'Race Differences in Intelligence',
1974 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1976 'upload_date': '20140124',
1979 'skip_download': True,
1981 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1985 'url': '1t24XAntNCY',
1986 'only_matching': True,
1989 # geo restricted to JP
1990 'url': 'sJL6WA-aGkQ',
1991 'only_matching': True,
1994 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1995 'only_matching': True,
1998 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1999 'only_matching': True,
2002 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2003 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2004 'only_matching': True,
2008 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2009 'only_matching': True,
2012 # Video with unsupported adaptive stream type formats
2013 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2015 'id': 'Z4Vy8R84T1U',
2017 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2018 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2020 'upload_date': '20130923',
2021 'formats': 'maxcount:10',
2024 'skip_download': True,
2025 'youtube_include_dash_manifest': False,
2027 'skip': 'not actual anymore',
2030 # Youtube Music Auto-generated description
2031 # TODO: fix metadata extraction
2032 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2034 'id': 'MgNrAu2pzNs',
2036 'title': 'Voyeur Girl',
2037 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2038 'upload_date': '20190312',
2039 'artist': 'Stephen',
2040 'track': 'Voyeur Girl',
2041 'album': 'it\'s too much love to know my dear',
2042 'release_date': '20190313',
2043 'release_year': 2019,
2044 'alt_title': 'Voyeur Girl',
2046 'playable_in_embed': True,
2048 'categories': ['Music'],
2049 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2050 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2051 'uploader': 'Stephen',
2052 'availability': 'public',
2053 'creator': 'Stephen',
2055 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2057 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2059 'live_status': 'not_live',
2060 'channel_follower_count': int
2063 'skip_download': True,
2067 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2068 'only_matching': True,
2071 # invalid -> valid video id redirection
2072 'url': 'DJztXj2GPfl',
2074 'id': 'DJztXj2GPfk',
2076 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2077 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2078 'upload_date': '20090125',
2079 'artist': 'Panjabi MC',
2080 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2081 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2084 'skip_download': True,
2086 'skip': 'Video unavailable',
2089 # empty description results in an empty string
2090 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2092 'id': 'x41yOUIvK2k',
2094 'title': 'IMG 3456',
2096 'upload_date': '20170613',
2098 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2100 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2102 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2103 'availability': 'public',
2105 'categories': ['Pets & Animals'],
2107 'playable_in_embed': True,
2108 'live_status': 'not_live',
2109 'channel': 'l\'Or Vert asbl',
2110 'channel_follower_count': int,
2111 'uploader': 'l\'Or Vert asbl',
2112 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2113 'uploader_id': '@ElevageOrVert',
2116 'skip_download': True,
2120 # with '};' inside yt initial data (see [1])
2121 # see [2] for an example with '};' inside ytInitialPlayerResponse
2122 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2123 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2124 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2126 'id': 'CHqg6qOn4no',
2128 'title': 'Part 77 Sort a list of simple types in c#',
2129 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2130 'upload_date': '20130831',
2131 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2133 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2134 'live_status': 'not_live',
2135 'categories': ['Education'],
2136 'availability': 'public',
2137 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2139 'playable_in_embed': True,
2143 'channel': 'kudvenkat',
2144 'comment_count': int,
2145 'channel_follower_count': int,
2147 'uploader': 'kudvenkat',
2148 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2149 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2152 'skip_download': True,
2156 # another example of '};' in ytInitialData
2157 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2158 'only_matching': True,
2161 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2162 'only_matching': True,
2165 # https://github.com/ytdl-org/youtube-dl/pull/28094
2166 'url': 'OtqTfy26tG0',
2168 'id': 'OtqTfy26tG0',
2170 'title': 'Burn Out',
2171 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2172 'upload_date': '20141120',
2173 'artist': 'The Cinematic Orchestra',
2174 'track': 'Burn Out',
2175 'album': 'Every Day',
2177 'live_status': 'not_live',
2178 'alt_title': 'Burn Out',
2182 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2183 'creator': 'The Cinematic Orchestra',
2184 'channel': 'The Cinematic Orchestra',
2185 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2186 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2187 'availability': 'public',
2188 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2189 'categories': ['Music'],
2190 'playable_in_embed': True,
2191 'channel_follower_count': int,
2192 'uploader': 'The Cinematic Orchestra',
2193 'comment_count': int,
2196 'skip_download': True,
2200 # controversial video, only works with bpctr when authenticated with cookies
2201 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2202 'only_matching': True,
2205 # controversial video, requires bpctr/contentCheckOk
2206 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2208 'id': 'SZJvDhaSDnc',
2210 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2211 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2212 'upload_date': '20140716',
2213 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2215 'categories': ['News & Politics'],
2217 'channel': 'CBS Mornings',
2218 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2219 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2221 'availability': 'needs_auth',
2222 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2224 'live_status': 'not_live',
2225 'playable_in_embed': True,
2226 'channel_follower_count': int,
2227 'uploader': 'CBS Mornings',
2228 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2229 'uploader_id': '@CBSMornings',
2233 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2234 'url': 'cBvYw8_A0vQ',
2236 'id': 'cBvYw8_A0vQ',
2238 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2239 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2240 'upload_date': '20201120',
2242 'categories': ['Travel & Events'],
2243 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2245 'channel': 'Walk around Japan',
2246 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2247 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2249 'availability': 'public',
2250 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2251 'live_status': 'not_live',
2252 'playable_in_embed': True,
2253 'channel_follower_count': int,
2254 'uploader': 'Walk around Japan',
2255 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2256 'uploader_id': '@walkaroundjapan7124',
2259 'skip_download': True,
2262 # Has multiple audio streams
2263 'url': 'WaOKSUlf4TM',
2264 'only_matching': True
2266 # Requires Premium: has format 141 when requested using YTM url
2267 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2268 'only_matching': True
2270 # multiple subtitles with same lang_code
2271 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2272 'only_matching': True,
2274 # Force use android client fallback
2275 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2277 'id': 'YOelRv7fMxY',
2278 'title': 'DIGGING A SECRET TUNNEL Part 1',
2280 'upload_date': '20210624',
2281 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2282 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2283 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2285 'categories': ['Entertainment'],
2287 'channel': 'colinfurze',
2288 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2289 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2291 'availability': 'public',
2293 'live_status': 'not_live',
2294 'playable_in_embed': True,
2295 'channel_follower_count': int,
2297 'uploader': 'colinfurze',
2298 'uploader_url': 'https://www.youtube.com/@colinfurze',
2299 'uploader_id': '@colinfurze',
2302 'format': '17', # 3gp format available on android
2303 'extractor_args': {'youtube': {'player_client': ['android']}},
2307 # Skip download of additional client configs (remix client config in this case)
2308 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2309 'only_matching': True,
2311 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2315 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2316 'only_matching': True,
2318 'note': 'Storyboards',
2319 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2321 'id': '5KLPxDtMqe8',
2324 'title': 'Your Brain is Plastic',
2325 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2326 'upload_date': '20140324',
2328 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2329 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2331 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2332 'playable_in_embed': True,
2334 'availability': 'public',
2335 'channel': 'SciShow',
2336 'live_status': 'not_live',
2338 'categories': ['Education'],
2340 'channel_follower_count': int,
2342 'uploader': 'SciShow',
2343 'uploader_url': 'https://www.youtube.com/@SciShow',
2344 'uploader_id': '@SciShow',
2345 }, 'params': {'format': 'mhtml', 'skip_download': True}
2347 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2348 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2350 'id': '2NUZ8W2llS4',
2352 'title': 'The NP that test your phone performance 🙂',
2353 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2354 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2355 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2359 'categories': ['Gaming'],
2361 'playable_in_embed': True,
2362 'live_status': 'not_live',
2363 'upload_date': '20220103',
2365 'availability': 'public',
2366 'channel': 'Leon Nguyen',
2367 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2368 'comment_count': int,
2369 'channel_follower_count': int,
2370 'uploader': 'Leon Nguyen',
2371 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2372 'uploader_id': '@LeonNguyen',
2375 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2376 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2378 'id': '2NUZ8W2llS4',
2380 'title': 'The NP that test your phone performance 🙂',
2381 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2382 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2383 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2387 'categories': ['Gaming'],
2389 'playable_in_embed': True,
2390 'live_status': 'not_live',
2391 'upload_date': '20220102',
2393 'availability': 'public',
2394 'channel': 'Leon Nguyen',
2395 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2396 'comment_count': int,
2397 'channel_follower_count': int,
2398 'uploader': 'Leon Nguyen',
2399 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2400 'uploader_id': '@LeonNguyen',
2402 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2404 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2405 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2407 'id': 'mzZzzBU6lrM',
2409 'title': 'I Met GeorgeNotFound In Real Life...',
2410 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2411 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2412 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2416 'categories': ['Entertainment'],
2418 'playable_in_embed': True,
2419 'live_status': 'not_live',
2420 'release_timestamp': 1641172509,
2421 'release_date': '20220103',
2422 'upload_date': '20220103',
2424 'availability': 'public',
2425 'channel': 'Quackity',
2426 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2427 'channel_follower_count': int,
2428 'uploader': 'Quackity',
2429 'uploader_id': '@Quackity',
2430 'uploader_url': 'https://www.youtube.com/@Quackity',
2433 { # continuous livestream. Microformat upload date should be preferred.
2434 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2435 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2437 'id': 'kgx4WGK0oNU',
2438 'title': r're:jazz\/lofi hip hop radio🌱chill beats to relax\/study to \[LIVE 24\/7\] \d{4}-\d{2}-\d{2} \d{2}:\d{2}',
2440 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2441 'availability': 'public',
2443 'release_timestamp': 1637975704,
2444 'upload_date': '20210619',
2445 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2446 'live_status': 'is_live',
2447 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2448 'channel': 'Abao in Tokyo',
2449 'channel_follower_count': int,
2450 'release_date': '20211127',
2452 'categories': ['People & Blogs'],
2455 'playable_in_embed': True,
2456 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2457 'concurrent_view_count': int,
2458 'uploader': 'Abao in Tokyo',
2459 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2460 'uploader_id': '@abaointokyo',
2462 'params': {'skip_download': True}
2464 # Story. Requires specific player params to work.
2465 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2467 'id': 'vv8qTUWmulI',
2469 'availability': 'unlisted',
2471 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2472 'upload_date': '20220526',
2473 'categories': ['Education'],
2475 'channel': 'IT\'S HISTORY',
2478 'playable_in_embed': True,
2480 'live_status': 'not_live',
2482 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2483 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2485 'skip': 'stories get removed after some period of time',
2487 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2489 'id': 'tjjjtzRLHvA',
2491 'title': 'ハッシュタグ無し };if window.ytcsi',
2492 'upload_date': '20220323',
2494 'availability': 'unlisted',
2495 'channel': 'Lesmiscore',
2496 'thumbnail': r're:^https?://.*\.jpg',
2498 'categories': ['Music'],
2501 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2502 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2503 'live_status': 'not_live',
2504 'playable_in_embed': True,
2505 'channel_follower_count': int,
2508 'uploader_id': '@lesmiscore',
2509 'uploader': 'Lesmiscore',
2510 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2513 # Prefer primary title+description language metadata by default
2514 # Do not prefer translated description if primary is empty
2515 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2517 'id': 'el3E4MbxRqQ',
2519 'title': 'dlp test video 2 - primary sv no desc',
2521 'channel': 'cole-dlp-test-acc',
2524 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2526 'playable_in_embed': True,
2527 'availability': 'unlisted',
2528 'thumbnail': r're:^https?://.*\.jpg',
2531 'live_status': 'not_live',
2532 'upload_date': '20220908',
2533 'categories': ['People & Blogs'],
2534 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2535 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2536 'uploader_id': '@coletdjnz',
2537 'uploader': 'cole-dlp-test-acc',
2539 'params': {'skip_download': True}
2541 # Extractor argument: prefer translated title+description
2542 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2544 'id': 'gHKT4uU8Zng',
2546 'channel': 'cole-dlp-test-acc',
2549 'live_status': 'not_live',
2550 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2551 'upload_date': '20220728',
2553 'categories': ['People & Blogs'],
2554 'thumbnail': r're:^https?://.*\.jpg',
2555 'title': 'dlp test video title translated (fr)',
2556 'availability': 'public',
2558 'description': 'dlp test video description translated (fr)',
2559 'playable_in_embed': True,
2560 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2561 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2562 'uploader_id': '@coletdjnz',
2563 'uploader': 'cole-dlp-test-acc',
2565 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2566 'expected_warnings': [r'Preferring "fr" translated fields'],
2568 'note': '6 channel audio',
2569 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2570 'only_matching': True,
2572 'note': 'Multiple HLS formats with same itag',
2573 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2575 'id': 'kX3nB4PpJko',
2577 'categories': ['Entertainment'],
2578 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2579 'live_status': 'not_live',
2581 'channel_follower_count': int,
2582 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2583 'title': 'Last To Take Hand Off Jet, Keeps It!',
2584 'channel': 'MrBeast',
2585 'playable_in_embed': True,
2587 'upload_date': '20221112',
2588 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2590 'availability': 'public',
2591 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2594 'uploader': 'MrBeast',
2595 'uploader_url': 'https://www.youtube.com/@MrBeast',
2596 'uploader_id': '@MrBeast',
2598 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2600 'note': 'Audio formats with Dynamic Range Compression',
2601 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2603 'id': 'Tq92D6wQ1mg',
2605 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2606 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2607 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2608 'channel_follower_count': int,
2609 'description': 'md5:17eccca93a786d51bc67646756894066',
2610 'upload_date': '20191228',
2611 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2612 'playable_in_embed': True,
2614 'categories': ['Entertainment'],
2615 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2617 'channel': 'Projekt Melody',
2619 'availability': 'needs_auth',
2620 'comment_count': int,
2621 'live_status': 'not_live',
2623 'uploader': 'Projekt Melody',
2624 'uploader_id': '@ProjektMelody',
2625 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2627 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2630 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2632 'id': 'qVv6vCqciTM',
2635 'comment_count': int,
2636 'chapters': 'count:13',
2637 'upload_date': '20221223',
2638 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2639 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2641 'release_date': '20221223',
2642 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2643 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2645 'playable_in_embed': True,
2647 'availability': 'public',
2648 'channel_follower_count': int,
2649 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2650 'categories': ['Entertainment'],
2651 'live_status': 'was_live',
2652 'release_timestamp': 1671793345,
2653 'channel': 'さなちゃんねる',
2654 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2655 'uploader': 'さなちゃんねる',
2656 'uploader_url': 'https://www.youtube.com/@sana_natori',
2657 'uploader_id': '@sana_natori',
2661 # Fallbacks when webpage and web client is unavailable
2662 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2664 'id': 'wSSmNUl9Snw',
2666 # 'categories': ['Science & Technology'],
2668 'chapters': 'count:2',
2669 'channel': 'Scott Manley',
2672 # 'availability': 'public',
2673 'channel_follower_count': int,
2674 'live_status': 'not_live',
2675 'upload_date': '20170831',
2678 'uploader_url': 'https://www.youtube.com/@scottmanley',
2679 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2680 'uploader': 'Scott Manley',
2681 'uploader_id': '@scottmanley',
2682 'title': 'The Computer Hack That Saved Apollo 14',
2683 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2684 'thumbnail': r're:^https?://.*\.webp',
2685 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2686 'playable_in_embed': True,
2689 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2695 # YouTube <object> embed
2697 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2698 'md5': '873c81d308b979f0e23ee7e620b312a3',
2700 'id': 'msN87y-iEx0',
2702 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2703 'upload_date': '20080526',
2704 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2706 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2707 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2708 'playable_in_embed': True,
2709 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2711 'comment_count': int,
2712 'channel': 'Christopher Sykes',
2713 'live_status': 'not_live',
2714 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2715 'availability': 'public',
2718 'categories': ['Science & Technology'],
2719 'channel_follower_count': int,
2720 'uploader': 'Christopher Sykes',
2721 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2722 'uploader_id': '@ChristopherSykesDocumentaries',
2725 'skip_download': True,
2731 def suitable(cls, url):
2732 from ..utils import parse_qs
2735 if qs.get('list', [None])[0]:
2737 return super().suitable(url)
2739 def __init__(self, *args, **kwargs):
2740 super().__init__(*args, **kwargs)
2741 self._code_cache = {}
2742 self._player_cache = {}
2744 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2745 lock = threading.Lock()
2746 start_time = time.time()
2747 formats = [f for f in formats if f.get('is_from_start')]
2749 def refetch_manifest(format_id, delay):
2750 nonlocal formats, start_time, is_live
2751 if time.time() <= start_time + delay:
2754 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2755 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2756 microformats = traverse_obj(
2757 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2759 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2760 is_live = live_status == 'is_live'
2761 start_time = time.time()
2763 def mpd_feed(format_id, delay):
2765 @returns (manifest_url, manifest_stream_number, is_live) or None
2767 for retry in self.RetryManager(fatal=False):
2769 refetch_manifest(format_id, delay)
2771 f = next((f for f in formats if f['format_id'] == format_id), None)
2774 retry.error = f'{video_id}: Video is no longer live'
2776 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2778 return f['manifest_url'], f['manifest_stream_number'], is_live
2782 f['is_live'] = is_live
2783 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2784 live_start_time, mpd_feed, not is_live and f.copy())
2786 f['fragments'] = gen
2787 f['protocol'] = 'http_dash_segments_generator'
2789 f['fragments'] = LazyList(gen({}))
2790 del f['is_from_start']
2792 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2793 FETCH_SPAN, MAX_DURATION = 5, 432000
2795 mpd_url, stream_number, is_live = None, None, True
2798 download_start_time = ctx.get('start') or time.time()
2800 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2801 if lack_early_segments:
2802 self.report_warning(bug_reports_message(
2803 'Starting download from the last 120 hours of the live stream since '
2804 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2805 lack_early_segments = True
2807 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2808 fragments, fragment_base_url = None, None
2810 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2811 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2812 # Obtain from MPD's maximum seq value
2813 old_mpd_url = mpd_url
2814 last_error = ctx.pop('last_error', None)
2815 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2816 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2817 or (mpd_url, stream_number, False))
2818 if not refresh_sequence:
2819 if expire_fast and not is_live:
2820 return False, last_seq
2821 elif old_mpd_url == mpd_url:
2822 return True, last_seq
2823 if manifestless_orig_fmt:
2824 fmt_info = manifestless_orig_fmt
2827 fmts, _ = self._extract_mpd_formats_and_subtitles(
2828 mpd_url, None, note=False, errnote=False, fatal=False)
2829 except ExtractorError:
2832 no_fragment_score += 2
2833 return False, last_seq
2834 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2835 fragments = fmt_info['fragments']
2836 fragment_base_url = fmt_info['fragment_base_url']
2837 assert fragment_base_url
2839 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2840 return True, _last_seq
2842 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2844 fetch_time = time.time()
2845 if no_fragment_score > 30:
2847 if last_segment_url:
2848 # Obtain from "X-Head-Seqnum" header value from each segment
2850 urlh = self._request_webpage(
2851 last_segment_url, None, note=False, errnote=False, fatal=False)
2852 except ExtractorError:
2854 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2855 if last_seq is None:
2856 no_fragment_score += 2
2857 last_segment_url = None
2860 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2861 no_fragment_score += 2
2862 if not should_continue:
2865 if known_idx > last_seq:
2866 last_segment_url = None
2871 if begin_index < 0 and known_idx < 0:
2872 # skip from the start when it's negative value
2873 known_idx = last_seq + begin_index
2874 if lack_early_segments:
2875 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2877 for idx in range(known_idx, last_seq):
2878 # do not update sequence here or you'll get skipped some part of it
2879 should_continue, _ = _extract_sequence_from_mpd(False, False)
2880 if not should_continue:
2882 raise ExtractorError('breaking out of outer loop')
2883 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2885 'url': last_segment_url,
2886 'fragment_count': last_seq,
2888 if known_idx == last_seq:
2889 no_fragment_score += 5
2891 no_fragment_score = 0
2892 known_idx = last_seq
2893 except ExtractorError:
2896 if manifestless_orig_fmt:
2897 # Stop at the first iteration if running for post-live manifestless;
2898 # fragment count no longer increase since it starts
2901 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2903 def _extract_player_url(self, *ytcfgs, webpage=None):
2904 player_url = traverse_obj(
2905 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2906 get_all=False, expected_type=str)
2909 return urljoin('https://www.youtube.com', player_url)
2911 def _download_player_url(self, video_id, fatal=False):
2912 res = self._download_webpage(
2913 'https://www.youtube.com/iframe_api',
2914 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2916 player_version = self._search_regex(
2917 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2919 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2921 def _signature_cache_id(self, example_sig):
2922 """ Return a string representation of a signature """
2923 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2926 def _extract_player_info(cls, player_url):
2927 for player_re in cls._PLAYER_INFO_RE:
2928 id_m = re.search(player_re, player_url)
2932 raise ExtractorError('Cannot identify player %r' % player_url)
2933 return id_m.group('id')
2935 def _load_player(self, video_id, player_url, fatal=True):
2936 player_id = self._extract_player_info(player_url)
2937 if player_id not in self._code_cache:
2938 code = self._download_webpage(
2939 player_url, video_id, fatal=fatal,
2940 note='Downloading player ' + player_id,
2941 errnote='Download of %s failed' % player_url)
2943 self._code_cache[player_id] = code
2944 return self._code_cache.get(player_id)
2946 def _extract_signature_function(self, video_id, player_url, example_sig):
2947 player_id = self._extract_player_info(player_url)
2949 # Read from filesystem cache
2950 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2951 assert os.path.basename(func_id) == func_id
2953 self.write_debug(f'Extracting signature function {func_id}')
2954 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2957 code = self._load_player(video_id, player_url)
2959 res = self._parse_sig_js(code)
2960 test_string = ''.join(map(chr, range(len(example_sig))))
2961 cache_spec = [ord(c) for c in res(test_string)]
2962 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2964 return lambda s: ''.join(s[i] for i in cache_spec)
2966 def _print_sig_code(self, func, example_sig):
2967 if not self.get_param('youtube_print_sig_code'):
2970 def gen_sig_code(idxs):
2971 def _genslice(start, end, step):
2972 starts = '' if start == 0 else str(start)
2973 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2974 steps = '' if step == 1 else (':%d' % step)
2975 return f's[{starts}{ends}{steps}]'
2978 # Quelch pyflakes warnings - start will be set when step is set
2979 start = '(Never used)'
2980 for i, prev in zip(idxs[1:], idxs[:-1]):
2981 if step is not None:
2982 if i - prev == step:
2984 yield _genslice(start, prev, step)
2987 if i - prev in [-1, 1]:
2992 yield 's[%d]' % prev
2996 yield _genslice(start, i, step)
2998 test_string = ''.join(map(chr, range(len(example_sig))))
2999 cache_res = func(test_string)
3000 cache_spec = [ord(c) for c in cache_res]
3001 expr_code = ' + '.join(gen_sig_code(cache_spec))
3002 signature_id_tuple = '(%s)' % (
3003 ', '.join(str(len(p)) for p in example_sig.split('.')))
3004 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3005 ' return %s\n') % (signature_id_tuple, expr_code)
3006 self.to_screen('Extracted signature function:\n' + code)
3008 def _parse_sig_js(self, jscode):
3009 funcname = self._search_regex(
3010 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3011 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3012 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3013 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3014 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+\))?',
3015 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3017 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3018 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3019 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3020 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3021 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3022 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3023 jscode, 'Initial JS player signature function name', group='sig')
3025 jsi = JSInterpreter(jscode)
3026 initial_function = jsi.extract_function(funcname)
3027 return lambda s: initial_function([s])
3029 def _cached(self, func, *cache_id):
3030 def inner(*args, **kwargs):
3031 if cache_id not in self._player_cache:
3033 self._player_cache[cache_id] = func(*args, **kwargs)
3034 except ExtractorError as e:
3035 self._player_cache[cache_id] = e
3036 except Exception as e:
3037 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3039 ret = self._player_cache[cache_id]
3040 if isinstance(ret, Exception):
3045 def _decrypt_signature(self, s, video_id, player_url):
3046 """Turn the encrypted s field into a working signature"""
3047 extract_sig = self._cached(
3048 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3049 func = extract_sig(video_id, player_url, s)
3050 self._print_sig_code(func, s)
3053 def _decrypt_nsig(self, s, video_id, player_url):
3054 """Turn the encrypted n field into a working signature"""
3055 if player_url is None:
3056 raise ExtractorError('Cannot decrypt nsig without player_url')
3057 player_url = urljoin('https://www.youtube.com', player_url)
3060 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3061 except ExtractorError as e:
3062 raise ExtractorError('Unable to extract nsig function code', cause=e)
3063 if self.get_param('youtube_print_sig_code'):
3064 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3067 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3068 ret = extract_nsig(jsi, func_code)(s)
3069 except JSInterpreter.Exception as e:
3071 jsi = PhantomJSwrapper(self, timeout=5000)
3072 except ExtractorError:
3074 self.report_warning(
3075 f'Native nsig extraction failed: Trying with PhantomJS\n'
3076 f' n = {s} ; player = {player_url}', video_id)
3077 self.write_debug(e, only_once=True)
3079 args, func_body = func_code
3081 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3082 video_id=video_id, note='Executing signature code').strip()
3084 self.write_debug(f'Decrypted nsig {s} => {ret}')
3087 def _extract_n_function_name(self, jscode):
3088 funcname, idx = self._search_regex(
3089 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3090 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3094 return json.loads(js_to_json(self._search_regex(
3095 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
3096 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3098 def _extract_n_function_code(self, video_id, player_url):
3099 player_id = self._extract_player_info(player_url)
3100 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3101 jscode = func_code or self._load_player(video_id, player_url)
3102 jsi = JSInterpreter(jscode)
3105 return jsi, player_id, func_code
3107 func_name = self._extract_n_function_name(jscode)
3110 func_code = self._search_regex(
3111 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3112 # NB: The end of the regex is intentionally kept strict
3113 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3114 jscode, 'nsig function', group=('var', 'code'), default=None)
3116 func_code = ([func_code[0]], func_code[1])
3118 self.write_debug('Extracting nsig function with jsinterp')
3119 func_code = jsi.extract_function_code(func_name)
3121 self.cache.store('youtube-nsig', player_id, func_code)
3122 return jsi, player_id, func_code
3124 def _extract_n_function_from_code(self, jsi, func_code):
3125 func = jsi.extract_function_from_code(*func_code)
3127 def extract_nsig(s):
3130 except JSInterpreter.Exception:
3132 except Exception as e:
3133 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3135 if ret.startswith('enhanced_except_'):
3136 raise JSInterpreter.Exception('Signature function returned an exception')
3141 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3143 Extract signatureTimestamp (sts)
3144 Required to tell API what sig/player version is in use.
3147 if isinstance(ytcfg, dict):
3148 sts = int_or_none(ytcfg.get('STS'))
3151 # Attempt to extract from player
3152 if player_url is None:
3153 error_msg = 'Cannot extract signature timestamp without player_url.'
3155 raise ExtractorError(error_msg)
3156 self.report_warning(error_msg)
3158 code = self._load_player(video_id, player_url, fatal=fatal)
3160 sts = int_or_none(self._search_regex(
3161 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3162 'JS player signature timestamp', group='sts', fatal=fatal))
3165 def _mark_watched(self, video_id, player_responses):
3166 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3167 label = 'fully ' if is_full else ''
3168 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3169 expected_type=url_or_none)
3171 self.report_warning(f'Unable to mark {label}watched')
3173 parsed_url = urllib.parse.urlparse(url)
3174 qs = urllib.parse.parse_qs(parsed_url.query)
3176 # cpn generation algorithm is reverse engineered from base.js.
3177 # In fact it works even with dummy cpn.
3178 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3179 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3181 # # more consistent results setting it to right before the end
3182 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3187 'cmt': video_length,
3188 'el': 'detailpage', # otherwise defaults to "shorts"
3192 # these seem to mark watchtime "history" in the real world
3193 # they're required, so send in a single value
3199 url = urllib.parse.urlunparse(
3200 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3202 self._download_webpage(
3203 url, video_id, f'Marking {label}watched',
3204 'Unable to mark watched', fatal=False)
3207 def _extract_from_webpage(cls, url, webpage):
3208 # Invidious Instances
3209 # https://github.com/yt-dlp/yt-dlp/issues/195
3210 # https://github.com/iv-org/invidious/pull/1730
3212 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3215 yield cls.url_result(mobj.group('url'), cls)
3216 raise cls.StopExtraction()
3218 yield from super()._extract_from_webpage(url, webpage)
3220 # lazyYT YouTube embed
3221 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3222 yield cls.url_result(unescapeHTML(id_), cls, id_)
3224 # Wordpress "YouTube Video Importer" plugin
3225 for m in re.findall(r'''(?x
)<div
[^
>]+
3226 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3227 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3228 yield cls.url_result(m[-1], cls, m[-1])
3231 def extract_id(cls, url):
3232 video_id = cls.get_temp_id(url)
3234 raise ExtractorError(f'Invalid URL: {url}')
3237 def _extract_chapters_from_json(self, data, duration):
3238 chapter_list = traverse_obj(
3240 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3241 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3242 ), expected_type=list)
3244 return self._extract_chapters_helper(
3246 start_function=lambda chapter: float_or_none(
3247 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3248 title_function=lambda chapter: traverse_obj(
3249 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3252 def _extract_chapters_from_engagement_panel(self, data, duration):
3253 content_list = traverse_obj(
3255 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3257 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3258 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3260 return next(filter(None, (
3261 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3262 chapter_time, chapter_title, duration)
3263 for contents in content_list)), [])
3265 def _extract_heatmap_from_player_overlay(self, data):
3266 content_list = traverse_obj(data, (
3267 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3268 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3269 return next(filter(None, (
3270 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3271 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3272 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3273 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3274 })) for contents in content_list)), None)
3276 def _extract_comment(self, comment_renderer, parent=None):
3277 comment_id = comment_renderer.get('commentId')
3283 'text': self._get_text(comment_renderer, 'contentText'),
3284 'like_count': self._get_count(comment_renderer, 'voteCount'),
3285 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3286 'author': self._get_text(comment_renderer, 'authorText'),
3287 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3288 'parent': parent or 'root',
3291 # Timestamp is an estimate calculated from the current time and time_text
3292 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3293 timestamp = self._parse_time_text(time_text)
3296 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3297 '_time_text': time_text,
3298 'timestamp': timestamp,
3301 info['author_url'] = urljoin(
3302 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3303 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3304 expected_type=str, get_all=False))
3306 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3307 if author_is_uploader is not None:
3308 info['author_is_uploader'] = author_is_uploader
3310 comment_abr = traverse_obj(
3311 comment_renderer, ('actionsButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3312 if comment_abr is not None:
3313 info['is_favorited'] = 'creatorHeart' in comment_abr
3315 comment_ab_icontype = traverse_obj(
3316 comment_renderer, ('authorCommentBadge', 'authorCommentBadgeRenderer', 'icon', 'iconType'))
3317 if comment_ab_icontype is not None:
3318 info['author_is_verified'] = comment_ab_icontype in ('CHECK_CIRCLE_THICK', 'OFFICIAL_ARTIST_BADGE')
3320 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3322 info['is_pinned'] = True
3326 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3328 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3330 def extract_header(contents):
3331 _continuation = None
3332 for content in contents:
3333 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3334 expected_comment_count = self._get_count(
3335 comments_header_renderer, 'countText', 'commentsCount')
3337 if expected_comment_count is not None:
3338 tracker['est_total'] = expected_comment_count
3339 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3340 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3342 sort_menu_item = try_get(
3343 comments_header_renderer,
3344 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3345 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3347 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3348 if not _continuation:
3351 sort_text = str_or_none(sort_menu_item.get('title'))
3353 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3354 self.to_screen('Sorting comments by %s' % sort_text.lower())
3356 return _continuation
3358 def extract_thread(contents):
3360 tracker['current_page_thread'] = 0
3361 for content in contents:
3362 if not parent and tracker['total_parent_comments'] >= max_parents:
3364 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3365 comment_renderer = get_first(
3366 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3367 expected_type=dict, default={})
3369 comment = self._extract_comment(comment_renderer, parent)
3372 comment_id = comment['id']
3373 if comment.get('is_pinned'):
3374 tracker['pinned_comment_ids'].add(comment_id)
3375 # Sometimes YouTube may break and give us infinite looping comments.
3376 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3377 if comment_id in tracker['seen_comment_ids']:
3378 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3379 # Pinned comments may appear a second time in newest first sort
3380 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3382 self.report_warning('Detected YouTube comments looping. Stopping comment extraction as we probably cannot get any more.')
3385 tracker['seen_comment_ids'].add(comment['id'])
3387 tracker['running_total'] += 1
3388 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3391 # Attempt to get the replies
3392 comment_replies_renderer = try_get(
3393 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3395 if comment_replies_renderer:
3396 tracker['current_page_thread'] += 1
3397 comment_entries_iter = self._comment_entries(
3398 comment_replies_renderer, ytcfg, video_id,
3399 parent=comment.get('id'), tracker=tracker)
3400 yield from itertools.islice(comment_entries_iter, min(
3401 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3403 # Keeps track of counts across recursive calls
3408 current_page_thread=0,
3409 total_parent_comments=0,
3410 total_reply_comments=0,
3411 seen_comment_ids=set(),
3412 pinned_comment_ids=set()
3416 # YouTube comments have a max depth of 2
3417 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3419 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3420 'Set max replies in the max-comments extractor argument instead')
3421 if max_depth == 1 and parent:
3424 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3425 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3427 continuation = self._extract_continuation(root_continuation_data)
3430 is_forced_continuation = False
3431 is_first_continuation = parent is None
3432 if is_first_continuation and not continuation:
3433 # Sometimes you can get comments by generating the continuation yourself,
3434 # even if YouTube initially reports them being disabled - e.g. stories comments.
3435 # Note: if the comment section is actually disabled, YouTube may return a response with
3436 # required check_get_keys missing. So we will disable that check initially in this case.
3437 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3438 is_forced_continuation = True
3440 continuation_items_path = (
3441 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3442 for page_num in itertools.count(0):
3443 if not continuation:
3445 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3446 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3448 if is_first_continuation:
3449 note_prefix = 'Downloading comment section API JSON'
3451 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3452 tracker['current_page_thread'], comment_prog_str)
3454 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3455 ' ' if parent else '', ' replies' if parent else '',
3456 page_num, comment_prog_str)
3458 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3459 # Ignore check if YouTube says the comment count is 0.
3460 check_get_keys = None
3461 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3462 check_get_keys = [[*continuation_items_path, ..., (
3463 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3465 response = self._extract_response(
3466 item_id=None, query=continuation,
3467 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3468 check_get_keys=check_get_keys)
3469 except ExtractorError as e:
3470 # Ignore incomplete data error for replies if retries didn't work.
3471 # This is to allow any other parent comments and comment threads to be downloaded.
3472 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3473 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3474 self.report_warning(
3475 'Received incomplete data for a comment reply thread and retrying did not help. '
3476 'Ignoring to let other comments be downloaded.')
3479 is_forced_continuation = False
3481 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3482 if is_first_continuation:
3483 continuation = extract_header(continuation_items)
3484 is_first_continuation = False
3489 for entry in extract_thread(continuation_items):
3493 continuation = self._extract_continuation({'contents': continuation_items})
3497 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3498 if message and not parent and tracker['running_total'] == 0:
3499 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3500 raise self.CommentsDisabled
3503 def _generate_comment_continuation(video_id):
3505 Generates initial comment section continuation token from given video id
3507 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3508 return base64.b64encode(token.encode()).decode()
3510 def _get_comments(self, ytcfg, video_id, contents, webpage):
3511 """Entry for comment extraction"""
3512 def _real_comment_extract(contents):
3514 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3515 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3516 yield from self._comment_entries(renderer, ytcfg, video_id)
3518 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3519 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3522 def _get_checkok_params():
3523 return {'contentCheckOk': True, 'racyCheckOk': True}
3526 def _generate_player_context(cls, sts=None):
3528 'html5Preference': 'HTML5_PREF_WANTS',
3531 context['signatureTimestamp'] = sts
3533 'playbackContext': {
3534 'contentPlaybackContext': context
3536 **cls._get_checkok_params()
3540 def _is_agegated(player_response):
3541 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3544 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3545 AGE_GATE_REASONS = (
3546 'confirm your age', 'age-restricted', 'inappropriate', # reason
3547 'age_verification_required', 'age_check_required', # status
3549 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3552 def _is_unplayable(player_response):
3553 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3555 _STORY_PLAYER_PARAMS = '8AEB'
3557 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3559 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3560 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3561 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3562 headers = self.generate_api_headers(
3563 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3566 'videoId': video_id,
3568 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3569 yt_query['params'] = self._STORY_PLAYER_PARAMS
3571 yt_query.update(self._generate_player_context(sts))
3572 return self._extract_response(
3573 item_id=video_id, ep='player', query=yt_query,
3574 ytcfg=player_ytcfg, headers=headers, fatal=True,
3575 default_client=client,
3576 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3579 def _get_requested_clients(self, url, smuggled_data):
3580 requested_clients = []
3581 default = ['android', 'web']
3582 allowed_clients = sorted(
3583 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3584 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3585 for client in self._configuration_arg('player_client'):
3586 if client in allowed_clients:
3587 requested_clients.append(client)
3588 elif client == 'default':
3589 requested_clients.extend(default)
3590 elif client == 'all':
3591 requested_clients.extend(allowed_clients)
3593 self.report_warning(f'Skipping unsupported client {client}')
3594 if not requested_clients:
3595 requested_clients = default
3597 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3598 requested_clients.extend(
3599 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3601 return orderedSet(requested_clients)
3603 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3606 initial_pr = self._search_json(
3607 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3609 all_clients = set(clients)
3610 clients = clients[::-1]
3613 def append_client(*client_names):
3614 """ Append the first client name that exists but not already used """
3615 for client_name in client_names:
3616 actual_client = _split_innertube_client(client_name)[0]
3617 if actual_client in INNERTUBE_CLIENTS:
3618 if actual_client not in all_clients:
3619 clients.append(client_name)
3620 all_clients.add(actual_client)
3623 # Android player_response does not have microFormats which are needed for
3624 # extraction of some data. So we return the initial_pr with formats
3625 # stripped out even if not requested by the user
3626 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3628 pr = dict(initial_pr)
3629 pr['streamingData'] = None
3633 tried_iframe_fallback = False
3636 client, base_client, variant = _split_innertube_client(clients.pop())
3637 player_ytcfg = master_ytcfg if client == 'web' else {}
3638 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3639 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3641 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3642 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3643 if 'js' in self._configuration_arg('player_skip'):
3644 require_js_player = False
3647 if not player_url and not tried_iframe_fallback and require_js_player:
3648 player_url = self._download_player_url(video_id)
3649 tried_iframe_fallback = True
3652 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3653 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3654 except ExtractorError as e:
3656 self.report_warning(last_error)
3661 # YouTube may return a different video player response than expected.
3662 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3663 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3664 if pr_video_id and pr_video_id != video_id:
3665 self.report_warning(
3666 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3668 # Save client name for introspection later
3669 name = short_client_name(client)
3670 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3671 sd[STREAMING_DATA_CLIENT_NAME] = name
3672 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3673 f[STREAMING_DATA_CLIENT_NAME] = name
3676 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3677 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3678 append_client(f'{base_client}_creator')
3679 elif self._is_agegated(pr):
3680 if variant == 'tv_embedded':
3681 append_client(f'{base_client}_embedded')
3683 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3688 self.report_warning(last_error)
3689 return prs, player_url
3691 def _needs_live_processing(self, live_status, duration):
3692 if (live_status == 'is_live' and self.get_param('live_from_start')
3693 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3696 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3697 CHUNK_SIZE = 10 << 20
3698 itags, stream_ids = collections.defaultdict(set), []
3699 itag_qualities, res_qualities = {}, {0: None}
3701 # Normally tiny is the smallest video-only formats. But
3702 # audio-only formats with unknown quality may get tagged as tiny
3704 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3705 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3707 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3708 all_formats = self._configuration_arg('include_duplicate_formats')
3710 def build_fragments(f):
3712 'url': update_url_query(f['url'], {
3713 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3715 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3717 for fmt in streaming_formats:
3718 if fmt.get('targetDurationSec'):
3721 itag = str_or_none(fmt.get('itag'))
3722 audio_track = fmt.get('audioTrack') or {}
3723 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3725 if stream_id in stream_ids:
3728 quality = fmt.get('quality')
3729 height = int_or_none(fmt.get('height'))
3730 if quality == 'tiny' or not quality:
3731 quality = fmt.get('audioQuality', '').lower() or quality
3732 # The 3gp format (17) in android client has a quality of "small
",
3733 # but is actually worse than other formats
3738 itag_qualities[itag] = quality
3740 res_qualities[height] = quality
3741 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3742 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3743 # number of fragment that would subsequently requested with (`&sq=N`)
3744 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3747 fmt_url = fmt.get('url')
3749 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3750 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3751 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3752 if not all((sc, fmt_url, player_url, encrypted_sig)):
3755 fmt_url += '&%s=%s' % (
3756 traverse_obj(sc, ('sp', -1)) or 'signature',
3757 self._decrypt_signature(encrypted_sig, video_id, player_url)
3759 except ExtractorError as e:
3760 self.report_warning('Signature extraction failed: Some formats may be missing',
3761 video_id=video_id, only_once=True)
3762 self.write_debug(e, only_once=True)
3765 query = parse_qs(fmt_url)
3769 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3770 fmt_url = update_url_query(fmt_url, {
3771 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3773 except ExtractorError as e:
3775 if isinstance(e, JSInterpreter.Exception):
3776 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3777 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3779 self.report_warning(
3780 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3781 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3782 self.write_debug(e, only_once=True)
3784 self.report_warning(
3785 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3786 video_id=video_id, only_once=True)
3789 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3790 language_preference = (
3791 10 if audio_track.get('audioIsDefault') and 10
3792 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3794 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3795 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3796 # Make sure to avoid false positives with small duration differences.
3797 # E.g. __2ABJjxzNo, ySuUZEjARPY
3798 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3800 self.report_warning(
3801 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3803 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3805 'asr': int_or_none(fmt.get('audioSampleRate')),
3806 'filesize': int_or_none(fmt.get('contentLength')),
3807 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3808 'format_note': join_nonempty(
3809 join_nonempty(audio_track.get('displayName'),
3810 language_preference > 0 and ' (default)', delim=''),
3811 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3812 fmt.get('isDrc') and 'DRC',
3813 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3814 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3815 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3816 (self.get_param('verbose') or all_formats) and client_name,
3818 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3819 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3820 'fps': int_or_none(fmt.get('fps')) or None,
3821 'audio_channels': fmt.get('audioChannels'),
3823 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3824 'has_drm': bool(fmt.get('drmFamilies')),
3827 'width': int_or_none(fmt.get('width')),
3828 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3829 'desc' if language_preference < -1 else '') or None,
3830 'language_preference': language_preference,
3831 # Strictly de-prioritize damaged and 3gp formats
3832 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3834 mime_mobj = re.match(
3835 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3837 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3838 dct.update(parse_codecs(mime_mobj.group(2)))
3840 itags[itag].add(('https
', dct.get('language
')))
3841 stream_ids.append(stream_id)
3842 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3843 if single_stream and dct.get('ext
'):
3844 dct['container
'] = dct['ext
'] + '_dash
'
3846 if all_formats and dct['filesize
']:
3849 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3850 'protocol
': 'http_dash_segments
',
3851 'fragments
': build_fragments(dct),
3853 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3856 needs_live_processing = self._needs_live_processing(live_status, duration)
3857 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3859 skip_manifests = set(self._configuration_arg('skip
'))
3860 if (not self.get_param('youtube_include_hls_manifest
', True)
3861 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3862 or needs_live_processing and skip_bad_formats):
3863 skip_manifests.add('hls
')
3865 if not self.get_param('youtube_include_dash_manifest
', True):
3866 skip_manifests.add('dash
')
3867 if self._configuration_arg('include_live_dash
'):
3868 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3869 'Use include_incomplete_formats extractor argument instead
')
3870 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3871 skip_manifests.add('dash
')
3873 def process_manifest_format(f, proto, client_name, itag):
3874 key = (proto, f.get('language
'))
3875 if not all_formats and key in itags[itag]:
3877 itags[itag].add(key)
3879 if itag and all_formats:
3880 f['format_id
'] = f'{itag}
-{proto}
'
3881 elif any(p != proto for p, _ in itags[itag]):
3882 f['format_id
'] = f'{itag}
-{proto}
'
3884 f['format_id
'] = itag
3886 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3887 if f['quality
'] == -1 and f.get('height
'):
3888 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3889 if self.get_param('verbose
'):
3890 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3894 for sd in streaming_data:
3895 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3897 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3898 if hls_manifest_url:
3899 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3900 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3901 subtitles = self._merge_subtitles(subs, subtitles)
3903 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3904 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3907 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3908 if dash_manifest_url:
3909 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3910 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3912 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3913 f['filesize
'] = int_or_none(self._search_regex(
3914 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3915 if needs_live_processing:
3916 f['is_from_start
'] = True
3921 def _extract_storyboard(self, player_responses, duration):
3923 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3924 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3928 for i, args in enumerate(spec):
3929 args = args.split('#')
3930 counts
= list(map(int_or_none
, args
[:5]))
3931 if len(args
) != 8 or not all(counts
):
3932 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3934 width
, height
, frame_count
, cols
, rows
= counts
3937 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3938 fragment_count
= frame_count
/ (cols
* rows
)
3939 fragment_duration
= duration
/ fragment_count
3941 'format_id': f
'sb{i}',
3942 'format_note': 'storyboard',
3944 'protocol': 'mhtml',
3950 'fps': frame_count
/ duration
,
3954 'url': url
.replace('$M', str(j
)),
3955 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3956 } for j
in range(math
.ceil(fragment_count
))],
3959 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3961 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3962 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3963 if smuggled_data
.get('is_story'):
3964 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3965 webpage
= self
._download
_webpage
(
3966 webpage_url
, video_id
, fatal
=False, query
=query
)
3968 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3970 player_responses
, player_url
= self
._extract
_player
_responses
(
3971 self
._get
_requested
_clients
(url
, smuggled_data
),
3972 video_id
, webpage
, master_ytcfg
, smuggled_data
)
3974 return webpage
, master_ytcfg
, player_responses
, player_url
3976 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
3977 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
3978 is_live
= get_first(video_details
, 'isLive')
3980 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
3981 live_content
= get_first(video_details
, 'isLiveContent')
3982 is_upcoming
= get_first(video_details
, 'isUpcoming')
3983 post_live
= get_first(video_details
, 'isPostLiveDvr')
3984 live_status
= ('post_live' if post_live
3985 else 'is_live' if is_live
3986 else 'is_upcoming' if is_upcoming
3987 else 'was_live' if live_content
3988 else 'not_live' if False in (is_live
, live_content
)
3990 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
3991 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
3993 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
3995 def _real_extract(self
, url
):
3996 url
, smuggled_data
= unsmuggle_url(url
, {})
3997 video_id
= self
._match
_id
(url
)
3999 base_url
= self
.http_scheme() + '//www.youtube.com/'
4000 webpage_url
= base_url
+ 'watch?v=' + video_id
4002 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4004 playability_statuses
= traverse_obj(
4005 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4007 trailer_video_id
= get_first(
4008 playability_statuses
,
4009 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4011 if trailer_video_id
:
4012 return self
.url_result(
4013 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4015 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4016 if webpage
else (lambda x
: None))
4018 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4019 microformats
= traverse_obj(
4020 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4023 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4024 video_title
= (self
._preferred
_lang
and translated_title
4025 or get_first(video_details
, 'title') # primary
4027 or search_meta(['og:title', 'twitter:title', 'title']))
4028 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4029 original_description
= get_first(video_details
, 'shortDescription')
4030 video_description
= (
4031 self
._preferred
_lang
and translated_description
4032 # If original description is blank, it will be an empty string.
4033 # Do not prefer translated description in this case.
4034 or original_description
if original_description
is not None else translated_description
)
4036 multifeed_metadata_list
= get_first(
4038 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4040 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4041 if self
.get_param('noplaylist'):
4042 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4046 for feed
in multifeed_metadata_list
.split(','):
4047 # Unquote should take place before split on comma (,) since textual
4048 # fields may contain comma as well (see
4049 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4050 feed_data
= urllib
.parse
.parse_qs(
4051 urllib
.parse
.unquote_plus(feed
))
4053 def feed_entry(name
):
4055 feed_data
, lambda x
: x
[name
][0], str)
4057 feed_id
= feed_entry('id')
4060 feed_title
= feed_entry('title')
4063 title
+= ' (%s)' % feed_title
4065 '_type': 'url_transparent',
4066 'ie_key': 'Youtube',
4068 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4069 {'force_singlefeed': True}
),
4072 feed_ids
.append(feed_id
)
4074 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4075 % (', '.join(feed_ids
), video_id
))
4076 return self
.playlist_result(
4077 entries
, video_id
, video_title
, video_description
)
4079 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4080 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4081 or parse_duration(search_meta('duration')) or None)
4083 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4084 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4085 if live_status
== 'post_live':
4086 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4089 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4090 self
.report_drm(video_id
)
4092 playability_statuses
,
4093 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4094 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4095 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4097 if subreason
== 'The uploader has not made this video available in your country.':
4098 countries
= get_first(microformats
, 'availableCountries')
4100 regions_allowed
= search_meta('regionsAllowed')
4101 countries
= regions_allowed
.split(',') if regions_allowed
else None
4102 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4103 reason
+= f
'. {subreason}'
4105 self
.raise_no_formats(reason
, expected
=True)
4107 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4108 if not keywords
and webpage
:
4110 unescapeHTML(m
.group('content'))
4111 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4112 for keyword
in keywords
:
4113 if keyword
.startswith('yt:stretch='):
4114 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4116 # NB: float is intentional for forcing float division
4117 w
, h
= (float(v
) for v
in mobj
.groups())
4121 if f
.get('vcodec') != 'none':
4122 f
['stretched_ratio'] = ratio
4124 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4125 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4128 'url': thumbnail_url
,
4130 original_thumbnails
= thumbnails
.copy()
4132 # The best resolution thumbnails sometimes does not appear in the webpage
4133 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4134 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4136 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4137 # in resolution, these are not the custom thumbnail. So de-prioritize them
4138 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4139 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4141 n_thumbnail_names
= len(thumbnail_names
)
4143 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4144 video_id
=video_id
, name
=name
, ext
=ext
,
4145 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4146 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4147 for thumb
in thumbnails
:
4148 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4149 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4150 self
._remove
_duplicate
_formats
(thumbnails
)
4151 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4153 category
= get_first(microformats
, 'category') or search_meta('genre')
4154 channel_id
= self
.ucid_or_none(str_or_none(
4155 get_first(video_details
, 'channelId')
4156 or get_first(microformats
, 'externalChannelId')
4157 or search_meta('channelId')))
4158 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4160 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4161 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4162 if not duration
and live_end_time
and live_start_time
:
4163 duration
= live_end_time
- live_start_time
4165 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4167 def is_bad_format(fmt
):
4168 if needs_live_processing
and not fmt
.get('is_from_start'):
4170 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4171 and fmt
.get('protocol') == 'http_dash_segments'):
4174 for fmt
in filter(is_bad_format
, formats
):
4175 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4176 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4178 if needs_live_processing
:
4179 self
._prepare
_live
_from
_start
_formats
(
4180 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4182 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4184 channel_handle
= self
.handle_from_url(owner_profile_url
)
4188 'title': video_title
,
4190 'thumbnails': thumbnails
,
4191 # The best thumbnail that we are sure exists. Prevents unnecessary
4192 # URL checking if user don't care about getting the best possible thumbnail
4193 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4194 'description': video_description
,
4195 'channel_id': channel_id
,
4196 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4197 'duration': duration
,
4198 'view_count': int_or_none(
4199 get_first((video_details
, microformats
), (..., 'viewCount'))
4200 or search_meta('interactionCount')),
4201 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4202 'age_limit': 18 if (
4203 get_first(microformats
, 'isFamilySafe') is False
4204 or search_meta('isFamilyFriendly') == 'false'
4205 or search_meta('og:restrictions:age') == '18+') else 0,
4206 'webpage_url': webpage_url
,
4207 'categories': [category
] if category
else None,
4209 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4210 'live_status': live_status
,
4211 'release_timestamp': live_start_time
,
4212 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4213 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4217 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4219 def get_lang_code(track
):
4220 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4221 or track
.get('languageCode'))
4223 # Converted into dicts to remove duplicates
4225 get_lang_code(sub
): sub
4226 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4227 translation_languages
= {
4228 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4229 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4231 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4232 lang_subs
= container
.setdefault(lang_code
, [])
4233 for fmt
in self
._SUBTITLE
_FORMATS
:
4239 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4243 # NB: Constructing the full subtitle dictionary is slow
4244 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4245 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4246 for lang_code
, caption_track
in captions
.items():
4247 base_url
= caption_track
.get('baseUrl')
4248 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4251 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4252 if caption_track
.get('kind') != 'asr':
4256 subtitles
, base_url
, lang_code
, lang_name
, {})
4257 if not caption_track
.get('isTranslatable'):
4259 for trans_code
, trans_name
in translation_languages
.items():
4262 orig_trans_code
= trans_code
4263 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4264 if not get_translated_subs
:
4266 trans_code
+= f
'-{lang_code}'
4267 trans_name
+= format_field(lang_name
, None, ' from %s')
4268 # Add an "-orig" label to the original language so that it can be distinguished.
4269 # The subs are returned without "-orig" as well for compatibility
4270 if lang_code
== f
'a-{orig_trans_code}':
4272 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4273 # Setting tlang=lang returns damaged subtitles.
4274 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4275 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4277 info
['automatic_captions'] = automatic_captions
4278 info
['subtitles'] = subtitles
4280 parsed_url
= urllib
.parse
.urlparse(url
)
4281 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4282 query
= urllib
.parse
.parse_qs(component
)
4283 for k
, v
in query
.items():
4284 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4286 if d_k
not in info
and k
in s_ks
:
4287 info
[d_k
] = parse_duration(query
[k
][0])
4289 # Youtube Music Auto-generated description
4290 if video_description
:
4293 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4295 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4296 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4297 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4298 .+\nAuto-generated\ by\ YouTube\.\s*$
4299 ''', video_description
)
4301 release_year
= mobj
.group('release_year')
4302 release_date
= mobj
.group('release_date')
4304 release_date
= release_date
.replace('-', '')
4305 if not release_year
:
4306 release_year
= release_date
[:4]
4308 'album': mobj
.group('album'.strip()),
4309 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4310 'track': mobj
.group('track').strip(),
4311 'release_date': release_date
,
4312 'release_year': int_or_none(release_year
),
4317 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4318 if not traverse_obj(initial_data
, 'contents'):
4319 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4321 if not initial_data
:
4322 query
= {'videoId': video_id}
4323 query
.update(self
._get
_checkok
_params
())
4324 initial_data
= self
._extract
_response
(
4325 item_id
=video_id
, ep
='next', fatal
=False,
4326 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4327 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4328 note
='Downloading initial data API JSON')
4330 info
['comment_count'] = traverse_obj(initial_data
, (
4331 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4332 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4334 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4335 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4336 ), expected_type
=self
._get
_count
, get_all
=False)
4338 try: # This will error if there is no livechat
4339 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4340 except (KeyError, IndexError, TypeError):
4343 info
.setdefault('subtitles', {})['live_chat'] = [{
4344 # url is needed to set cookies
4345 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4346 'video_id': video_id
,
4348 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4349 else 'youtube_live_chat_replay'),
4353 info
['chapters'] = (
4354 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4355 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4356 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4359 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4361 contents
= traverse_obj(
4362 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4363 expected_type
=list, default
=[])
4365 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4367 stl
= vpir
.get('superTitleLink')
4369 stl
= self
._get
_text
(stl
)
4372 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4373 info
['location'] = stl
4375 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4378 'series': mobj
.group(1),
4379 'season_number': int(mobj
.group(2)),
4380 'episode_number': int(mobj
.group(3)),
4382 for tlb
in (try_get(
4384 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4388 tlb
, ('toggleButtonRenderer', ...),
4389 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4391 for getter
, regex
in [(
4392 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4393 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4394 lambda x
: x
['accessibility'],
4395 lambda x
: x
['accessibilityData']['accessibilityData'],
4396 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4397 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4399 mobj
= re
.match(regex
, label
)
4401 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4403 sbr_tooltip
= try_get(
4404 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4406 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4408 'like_count': str_to_int(like_count
),
4409 'dislike_count': str_to_int(dislike_count
),
4411 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4413 vc
= self
._get
_count
(vcr
, 'viewCount')
4414 # Upcoming premieres with waiting count are treated as live here
4415 if vcr
.get('isLive'):
4416 info
['concurrent_view_count'] = vc
4417 elif info
.get('view_count') is None:
4418 info
['view_count'] = vc
4420 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4422 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4424 'channel': self
._get
_text
(vor
, 'title'),
4425 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4427 if not channel_handle
:
4428 channel_handle
= self
.handle_from_url(
4430 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4431 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4432 {str}
), get_all
=False))
4436 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4438 multiple_songs
= False
4440 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4441 multiple_songs
= True
4444 mrr
= row
.get('metadataRowRenderer') or {}
4445 mrr_title
= mrr
.get('title')
4448 mrr_title
= self
._get
_text
(mrr
, 'title')
4449 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4450 if mrr_title
== 'License':
4451 info
['license'] = mrr_contents_text
4452 elif not multiple_songs
:
4453 if mrr_title
== 'Album':
4454 info
['album'] = mrr_contents_text
4455 elif mrr_title
== 'Artist':
4456 info
['artist'] = mrr_contents_text
4457 elif mrr_title
== 'Song':
4458 info
['track'] = mrr_contents_text
4461 'uploader': info
.get('channel'),
4462 'uploader_id': channel_handle
,
4463 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4465 # The upload date for scheduled, live and past live streams / premieres in microformats
4466 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4467 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4469 unified_strdate(get_first(microformats
, 'uploadDate'))
4470 or unified_strdate(search_meta('uploadDate')))
4471 if not upload_date
or (
4472 live_status
in ('not_live', None)
4473 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4475 upload_date
= strftime_or_none(
4476 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4477 info
['upload_date'] = upload_date
4479 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4484 badges
= self
._extract
_badges
(traverse_obj(contents
, (..., 'videoPrimaryInfoRenderer'), get_all
=False))
4486 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4487 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4489 info
['availability'] = (
4490 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4491 else self
._availability
(
4492 is_private
=is_private
,
4494 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4495 or False if initial_data
and is_private
is not None else None),
4496 needs_subscription
=(
4497 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4498 or False if initial_data
and is_private
is not None else None),
4499 needs_auth
=info
['age_limit'] >= 18,
4500 is_unlisted
=None if is_private
is None else (
4501 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4502 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4504 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4506 self
.mark_watched(video_id
, player_responses
)
4511 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4513 def passthrough_smuggled_data(func
):
4514 def _smuggle(info
, smuggled_data
):
4515 if info
.get('_type') not in ('url', 'url_transparent'):
4517 if smuggled_data
.get('is_music_url'):
4518 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4519 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4520 smuggled_data
.pop('is_music_url')
4521 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4523 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4526 @functools.wraps(func
)
4527 def wrapper(self
, url
):
4528 url
, smuggled_data
= unsmuggle_url(url
, {})
4529 if self
.is_music_url(url
):
4530 smuggled_data
['is_music_url'] = True
4531 info_dict
= func(self
, url
, smuggled_data
)
4533 _smuggle(info_dict
, smuggled_data
)
4534 if info_dict
.get('entries'):
4535 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4540 def _extract_basic_item_renderer(item
):
4541 # Modified from _extract_grid_item_renderer
4542 known_basic_renderers
= (
4543 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4545 for key
, renderer
in item
.items():
4546 if not isinstance(renderer
, dict):
4548 elif key
in known_basic_renderers
:
4550 elif key
.startswith('grid') and key
.endswith('Renderer'):
4553 def _extract_channel_renderer(self
, renderer
):
4554 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4555 title
= self
._get
_text
(renderer
, 'title')
4556 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4557 # As of 2023-03-01 YouTube doesn't use the channel handles on these renderers yet.
4558 # However we can expect them to change that in the future.
4559 channel_handle
= self
.handle_from_url(
4560 traverse_obj(renderer
, (
4561 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4562 ('browseEndpoint', 'canonicalBaseUrl')),
4563 {str}
), get_all
=False))
4568 'ie_key': YoutubeTabIE
.ie_key(),
4571 'channel_id': channel_id
,
4572 'channel_url': channel_url
,
4574 'uploader_id': channel_handle
,
4575 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4576 'channel_follower_count': self
._get
_count
(renderer
, 'subscriberCountText'),
4577 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4578 'playlist_count': self
._get
_count
(renderer
, 'videoCountText'),
4579 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4582 def _grid_entries(self
, grid_renderer
):
4583 for item
in grid_renderer
['items']:
4584 if not isinstance(item
, dict):
4586 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4587 if not isinstance(renderer
, dict):
4589 title
= self
._get
_text
(renderer
, 'title')
4592 playlist_id
= renderer
.get('playlistId')
4594 yield self
.url_result(
4595 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4596 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4600 video_id
= renderer
.get('videoId')
4602 yield self
._extract
_video
(renderer
)
4605 channel_id
= renderer
.get('channelId')
4607 yield self
._extract
_channel
_renderer
(renderer
)
4609 # generic endpoint URL support
4610 ep_url
= urljoin('https://www.youtube.com/', try_get(
4611 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4614 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4615 if ie
.suitable(ep_url
):
4616 yield self
.url_result(
4617 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4620 def _music_reponsive_list_entry(self
, renderer
):
4621 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4623 title
= traverse_obj(renderer
, (
4624 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4625 'text', 'runs', 0, 'text'))
4626 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4627 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4628 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4630 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4632 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4633 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4634 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4635 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4636 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4638 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4639 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4641 def _shelf_entries_from_content(self
, shelf_renderer
):
4642 content
= shelf_renderer
.get('content')
4643 if not isinstance(content
, dict):
4645 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4647 # TODO: add support for nested playlists so each shelf is processed
4648 # as separate playlist
4649 # TODO: this includes only first N items
4650 yield from self
._grid
_entries
(renderer
)
4651 renderer
= content
.get('horizontalListRenderer')
4656 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4658 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4660 shelf_url
= urljoin('https://www.youtube.com', ep
)
4662 # Skipping links to another channels, note that checking for
4663 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4665 if skip_channels
and '/channels?' in shelf_url
:
4667 title
= self
._get
_text
(shelf_renderer
, 'title')
4668 yield self
.url_result(shelf_url
, video_title
=title
)
4669 # Shelf may not contain shelf URL, fallback to extraction from content
4670 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4672 def _playlist_entries(self
, video_list_renderer
):
4673 for content
in video_list_renderer
['contents']:
4674 if not isinstance(content
, dict):
4676 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4677 if not isinstance(renderer
, dict):
4679 video_id
= renderer
.get('videoId')
4682 yield self
._extract
_video
(renderer
)
4684 def _rich_entries(self
, rich_grid_renderer
):
4685 renderer
= traverse_obj(
4687 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4688 video_id
= renderer
.get('videoId')
4690 yield self
._extract
_video
(renderer
)
4692 playlist_id
= renderer
.get('playlistId')
4694 yield self
.url_result(
4695 f
'https://www.youtube.com/playlist?list={playlist_id}',
4696 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4697 video_title
=self
._get
_text
(renderer
, 'title'))
4700 def _video_entry(self
, video_renderer
):
4701 video_id
= video_renderer
.get('videoId')
4703 return self
._extract
_video
(video_renderer
)
4705 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4706 url
= urljoin('https://youtube.com', traverse_obj(
4707 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4709 return self
.url_result(
4710 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4712 def _post_thread_entries(self
, post_thread_renderer
):
4713 post_renderer
= try_get(
4714 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4715 if not post_renderer
:
4718 video_renderer
= try_get(
4719 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4720 video_id
= video_renderer
.get('videoId')
4722 entry
= self
._extract
_video
(video_renderer
)
4725 # playlist attachment
4726 playlist_id
= try_get(
4727 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4729 yield self
.url_result(
4730 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4731 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4732 # inline video links
4733 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4735 if not isinstance(run
, dict):
4738 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4741 if not YoutubeIE
.suitable(ep_url
):
4743 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4744 if video_id
== ep_video_id
:
4746 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4748 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4749 contents
= post_thread_continuation
.get('contents')
4750 if not isinstance(contents
, list):
4752 for content
in contents
:
4753 renderer
= content
.get('backstagePostThreadRenderer')
4754 if isinstance(renderer
, dict):
4755 yield from self
._post
_thread
_entries
(renderer
)
4757 renderer
= content
.get('videoRenderer')
4758 if isinstance(renderer
, dict):
4759 yield self
._video
_entry
(renderer
)
4762 def _rich_grid_entries(self, contents):
4763 for content in contents:
4764 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4766 entry = self._video_entry(video_renderer)
4771 def _report_history_entries(self
, renderer
):
4772 for url
in traverse_obj(renderer
, (
4773 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4774 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4775 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4776 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4778 def _extract_entries(self
, parent_renderer
, continuation_list
):
4779 # continuation_list is modified in-place with continuation_list = [continuation_token]
4780 continuation_list
[:] = [None]
4781 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4782 for content
in contents
:
4783 if not isinstance(content
, dict):
4785 is_renderer
= traverse_obj(
4786 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4789 if content
.get('richItemRenderer'):
4790 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4792 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4793 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4794 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4795 yield from self
._report
_history
_entries
(table
)
4796 continuation_list
[0] = self
._extract
_continuation
(table
)
4799 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4800 for isr_content
in isr_contents
:
4801 if not isinstance(isr_content
, dict):
4805 'playlistVideoListRenderer': self
._playlist
_entries
,
4806 'gridRenderer': self
._grid
_entries
,
4807 'reelShelfRenderer': self
._grid
_entries
,
4808 'shelfRenderer': self
._shelf
_entries
,
4809 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4810 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4811 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4812 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4813 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4814 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4816 for key
, renderer
in isr_content
.items():
4817 if key
not in known_renderers
:
4819 for entry
in known_renderers
[key
](renderer
):
4822 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4825 if not continuation_list
[0]:
4826 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4828 if not continuation_list
[0]:
4829 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4831 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4832 continuation_list
= [None]
4833 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4834 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4838 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4839 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4840 yield from extract_entries(parent_renderer
)
4841 continuation
= continuation_list
[0]
4843 for page_num
in itertools
.count(1):
4844 if not continuation
:
4846 headers
= self
.generate_api_headers(
4847 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4848 response
= self
._extract
_response
(
4849 item_id
=f
'{item_id} page {page_num}',
4850 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4851 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4855 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4856 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4857 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4860 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4861 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4862 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4863 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4864 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4865 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4866 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4867 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4868 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4869 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4870 'gridContinuation': (self
._grid
_entries
, None),
4871 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4872 'sectionListContinuation': (extract_entries
, None), # for feeds
4875 continuation_items
= traverse_obj(response
, (
4876 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4877 'appendContinuationItemsAction', 'continuationItems'
4878 ), 'continuationContents', get_all
=False)
4879 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4881 video_items_renderer
= None
4882 for key
in continuation_item
.keys():
4883 if key
not in known_renderers
:
4885 func
, parent_key
= known_renderers
[key
]
4886 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4887 continuation_list
= [None]
4888 yield from func(video_items_renderer
)
4889 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4891 if not video_items_renderer
:
4895 def _extract_selected_tab(tabs
, fatal
=True):
4896 for tab_renderer
in tabs
:
4897 if tab_renderer
.get('selected'):
4900 raise ExtractorError('Unable to find selected tab')
4903 def _extract_tab_renderers(response
):
4904 return traverse_obj(
4905 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4907 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4908 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4910 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4911 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4912 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4914 return self
.playlist_result(
4916 selected_tab
, metadata
['id'], ytcfg
,
4917 self
._extract
_account
_syncid
(ytcfg
, data
),
4918 self
._extract
_visitor
_data
(data
, ytcfg
)),
4921 def _extract_metadata_from_tabs(self
, item_id
, data
):
4922 info
= {'id': item_id}
4924 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4925 if metadata_renderer
:
4926 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
4927 ('channelUrl', {self.ucid_from_url}
))
4929 'channel': metadata_renderer
.get('title'),
4930 'channel_id': channel_id
,
4932 if info
['channel_id']:
4933 info
['id'] = info
['channel_id']
4935 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4937 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4938 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4939 def _get_uncropped(url
):
4940 return url_or_none((url
or '').split('=')[0] + '=s0')
4942 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4943 if avatar_thumbnails
:
4944 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4945 if uncropped_avatar
:
4946 avatar_thumbnails
.append({
4947 'url': uncropped_avatar
,
4948 'id': 'avatar_uncropped',
4952 channel_banners
= self
._extract
_thumbnails
(
4953 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4954 for banner
in channel_banners
:
4955 banner
['preference'] = -10
4958 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4959 if uncropped_banner
:
4960 channel_banners
.append({
4961 'url': uncropped_banner
,
4962 'id': 'banner_uncropped',
4966 # Deprecated - remove primary_sidebar_renderer when layout discontinued
4967 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
4968 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
4970 primary_thumbnails
= self
._extract
_thumbnails
(
4971 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
4972 playlist_thumbnails
= self
._extract
_thumbnails
(
4973 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
4976 'title': (traverse_obj(metadata_renderer
, 'title')
4977 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
4979 'availability': self
._extract
_availability
(data
),
4980 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
4981 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
4982 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
4983 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
4987 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
4988 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
4992 'uploader_id': channel_handle
,
4993 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4995 # Playlist stats is a text runs array containing [video count, view count, last updated].
4996 # last updated or (view count and last updated) may be missing.
4997 playlist_stats
= get_first(
4998 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5000 last_updated_unix
= self
._parse
_time
_text
(
5001 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5002 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5003 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
5005 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5006 if info
['view_count'] is None: # 0 is allowed
5007 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5008 if info
['view_count'] is None:
5009 info
['view_count'] = self
._get
_count
(data
, (
5010 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5011 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5013 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5014 if info
['playlist_count'] is None: # 0 is allowed
5015 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5017 if not info
.get('channel_id'):
5018 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5019 if not owner
: # Deprecated
5020 owner
= traverse_obj(
5021 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5022 ('videoOwner', 'videoOwnerRenderer', 'title'))
5023 owner_text
= self
._get
_text
(owner
)
5024 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5026 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5027 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5028 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5032 'uploader': info
['channel'],
5033 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5034 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5039 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5040 first_id
= last_id
= response
= None
5041 for page_num
in itertools
.count(1):
5042 videos
= list(self
._playlist
_entries
(playlist
))
5045 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5046 if start
>= len(videos
):
5048 yield from videos
[start
:]
5049 first_id
= first_id
or videos
[0]['id']
5050 last_id
= videos
[-1]['id']
5051 watch_endpoint
= try_get(
5052 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5053 headers
= self
.generate_api_headers(
5054 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5055 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5057 'playlistId': playlist_id
,
5058 'videoId': watch_endpoint
.get('videoId') or last_id
,
5059 'index': watch_endpoint
.get('index') or len(videos
),
5060 'params': watch_endpoint
.get('params') or 'OAE%3D'
5062 response
= self
._extract
_response
(
5063 item_id
='%s page %d' % (playlist_id
, page_num
),
5064 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5065 check_get_keys
='contents'
5068 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5070 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5071 title
= playlist
.get('title') or try_get(
5072 data
, lambda x
: x
['titleText']['simpleText'], str)
5073 playlist_id
= playlist
.get('playlistId') or item_id
5075 # Delegating everything except mix playlists to regular tab-based playlist URL
5076 playlist_url
= urljoin(url
, try_get(
5077 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5080 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5081 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5082 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5084 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5085 return self
.url_result(
5086 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5089 return self
.playlist_result(
5090 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5091 playlist_id
=playlist_id
, playlist_title
=title
)
5093 def _extract_availability(self
, data
):
5095 Gets the availability of a given playlist/tab.
5096 Note: Unless YouTube tells us explicitly, we do not assume it is public
5097 @param data: response
5099 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5100 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5101 player_header_privacy
= playlist_header_renderer
.get('privacy')
5103 badges
= self
._extract
_badges
(sidebar_renderer
)
5105 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5106 privacy_setting_icon
= get_first(
5107 (playlist_header_renderer
, sidebar_renderer
),
5108 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5109 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5112 microformats_is_unlisted
= traverse_obj(
5113 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5117 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5118 or player_header_privacy
== 'PUBLIC'
5119 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5120 else self
._availability
(
5122 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5123 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5124 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5126 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5127 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5128 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5129 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5130 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5131 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5135 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5136 sidebar_renderer
= try_get(
5137 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5138 for item
in sidebar_renderer
:
5139 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5143 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5145 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5147 is_playlist
= bool(traverse_obj(
5148 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5151 headers
= self
.generate_api_headers(
5152 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5153 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5155 'params': 'wgYCCAA=',
5156 'browseId': f
'VL{item_id}'
5158 return self
._extract
_response
(
5159 item_id
=item_id
, headers
=headers
, query
=query
,
5160 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5161 note
='Redownloading playlist API JSON with unavailable videos')
5163 @functools.cached_property
5164 def skip_webpage(self
):
5165 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5167 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5168 webpage
, data
= None, None
5169 for retry
in self
.RetryManager(fatal
=fatal
):
5171 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5172 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5173 except ExtractorError
as e
:
5174 if isinstance(e
.cause
, network_exceptions
):
5175 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5178 self
._error
_or
_warning
(e
, fatal
=fatal
)
5182 self
._extract
_and
_report
_alerts
(data
)
5183 except ExtractorError
as e
:
5184 self
._error
_or
_warning
(e
, fatal
=fatal
)
5187 # Sometimes youtube returns a webpage with incomplete ytInitialData
5188 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5189 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5190 retry
.error
= ExtractorError('Incomplete yt initial data received')
5193 return webpage
, data
5195 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5196 """Use if failed to extract ytcfg (and data) from initial webpage"""
5197 if not ytcfg
and self
.is_authenticated
:
5198 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5199 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5200 raise ExtractorError(
5201 f
'{msg}. If you are not downloading private content, or '
5202 'your cookies are only for the first account and channel,'
5203 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5205 self
.report_warning(msg
, only_once
=True)
5207 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5209 if not self
.skip_webpage
:
5210 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5211 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5212 # Reject webpage data if redirected to home page without explicitly requesting
5213 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5214 if (url
!= 'https://www.youtube.com/feed/recommended'
5215 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5216 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5217 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5219 raise ExtractorError(msg
, expected
=True)
5220 self
.report_warning(msg
, only_once
=True)
5222 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5223 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5226 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5227 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5228 resolve_response
= self
._extract
_response
(
5229 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5230 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5231 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5232 for ep_key
, ep
in endpoints
.items():
5233 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5235 return self
._extract
_response
(
5236 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5237 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5238 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5239 err_note
= 'Failed to resolve url (does the playlist exist?)'
5241 raise ExtractorError(err_note
, expected
=True)
5242 self
.report_warning(err_note
, item_id
)
5244 _SEARCH_PARAMS
= None
5246 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5247 data
= {'query': query}
5248 if params
is NO_DEFAULT
:
5249 params
= self
._SEARCH
_PARAMS
5251 data
['params'] = params
5254 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5255 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5257 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5258 ('continuationContents', ),
5260 display_id
= f
'query "{query}"'
5261 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5262 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5263 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5265 continuation_list
= [None]
5267 for page_num
in itertools
.count(1):
5268 data
.update(continuation_list
[0] or {})
5269 headers
= self
.generate_api_headers(
5270 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5271 search
= self
._extract
_response
(
5272 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5273 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5274 slr_contents
= traverse_obj(search
, *content_keys
)
5275 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5276 if not continuation_list
[0]:
5280 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5281 IE_DESC
= 'YouTube Tabs'
5282 _VALID_URL
= r
'''(?x:
5284 (?!consent\.)(?:\w+\.)?
5286 youtube(?:kids)?\.com|
5290 (?P<channel_type>channel|c|user|browse)/|
5293 (?:playlist|watch)\?.*?\blist=
5295 (?!(?:%(reserved_names)s)\b) # Direct URLs
5299 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5300 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5302 IE_NAME
= 'youtube:tab'
5305 'note': 'playlists, multipage',
5306 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5307 'playlist_mincount': 94,
5309 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5310 'title': 'Igor Kleiner - Playlists',
5311 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5312 'uploader': 'Igor Kleiner',
5313 'uploader_id': '@IgorDataScience',
5314 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5315 'channel': 'Igor Kleiner',
5316 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5317 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5318 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5319 'channel_follower_count': int
5322 'note': 'playlists, multipage, different order',
5323 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5324 'playlist_mincount': 94,
5326 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5327 'title': 'Igor Kleiner - Playlists',
5328 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5329 'uploader': 'Igor Kleiner',
5330 'uploader_id': '@IgorDataScience',
5331 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5332 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5333 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5334 'channel': 'Igor Kleiner',
5335 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5336 'channel_follower_count': int
5339 'note': 'playlists, series',
5340 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5341 'playlist_mincount': 5,
5343 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5344 'title': '3Blue1Brown - Playlists',
5345 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5346 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5347 'channel': '3Blue1Brown',
5348 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5349 'uploader_id': '@3blue1brown',
5350 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5351 'uploader': '3Blue1Brown',
5352 'tags': ['Mathematics'],
5353 'channel_follower_count': int
5356 'note': 'playlists, singlepage',
5357 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5358 'playlist_mincount': 4,
5360 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5361 'title': 'ThirstForScience - Playlists',
5362 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5363 'uploader': 'ThirstForScience',
5364 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5365 'uploader_id': '@ThirstForScience',
5366 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5367 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5369 'channel': 'ThirstForScience',
5370 'channel_follower_count': int
5373 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5374 'only_matching': True,
5376 'note': 'basic, single video playlist',
5377 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5379 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5380 'title': 'youtube-dl public playlist',
5384 'modified_date': '20201130',
5385 'channel': 'Sergey M.',
5386 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5387 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5388 'availability': 'public',
5389 'uploader': 'Sergey M.',
5390 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5391 'uploader_id': '@sergeym.6173',
5393 'playlist_count': 1,
5395 'note': 'empty playlist',
5396 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5398 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5399 'title': 'youtube-dl empty playlist',
5401 'channel': 'Sergey M.',
5403 'modified_date': '20160902',
5404 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5405 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5406 'availability': 'public',
5407 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5408 'uploader_id': '@sergeym.6173',
5409 'uploader': 'Sergey M.',
5411 'playlist_count': 0,
5414 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5416 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5417 'title': 'lex will - Home',
5418 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5419 'uploader': 'lex will',
5420 'uploader_id': '@lexwill718',
5421 'channel': 'lex will',
5422 'tags': ['bible', 'history', 'prophesy'],
5423 'uploader_url': 'https://www.youtube.com/@lexwill718',
5424 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5425 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5426 'channel_follower_count': int
5428 'playlist_mincount': 2,
5430 'note': 'Videos tab',
5431 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5433 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5434 'title': 'lex will - Videos',
5435 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5436 'uploader': 'lex will',
5437 'uploader_id': '@lexwill718',
5438 'tags': ['bible', 'history', 'prophesy'],
5439 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5440 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5441 'uploader_url': 'https://www.youtube.com/@lexwill718',
5442 'channel': 'lex will',
5443 'channel_follower_count': int
5445 'playlist_mincount': 975,
5447 'note': 'Videos tab, sorted by popular',
5448 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5450 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5451 'title': 'lex will - Videos',
5452 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5453 'uploader': 'lex will',
5454 'uploader_id': '@lexwill718',
5455 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5456 'uploader_url': 'https://www.youtube.com/@lexwill718',
5457 'channel': 'lex will',
5458 'tags': ['bible', 'history', 'prophesy'],
5459 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5460 'channel_follower_count': int
5462 'playlist_mincount': 199,
5464 'note': 'Playlists tab',
5465 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5467 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5468 'title': 'lex will - Playlists',
5469 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5470 'uploader': 'lex will',
5471 'uploader_id': '@lexwill718',
5472 'uploader_url': 'https://www.youtube.com/@lexwill718',
5473 'channel': 'lex will',
5474 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5475 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5476 'tags': ['bible', 'history', 'prophesy'],
5477 'channel_follower_count': int
5479 'playlist_mincount': 17,
5481 'note': 'Community tab',
5482 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5484 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5485 'title': 'lex will - Community',
5486 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5487 'channel': 'lex will',
5488 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5489 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5490 'tags': ['bible', 'history', 'prophesy'],
5491 'channel_follower_count': int,
5492 'uploader_url': 'https://www.youtube.com/@lexwill718',
5493 'uploader_id': '@lexwill718',
5494 'uploader': 'lex will',
5496 'playlist_mincount': 18,
5498 'note': 'Channels tab',
5499 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5501 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5502 'title': 'lex will - Channels',
5503 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5504 'channel': 'lex will',
5505 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5506 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5507 'tags': ['bible', 'history', 'prophesy'],
5508 'channel_follower_count': int,
5509 'uploader_url': 'https://www.youtube.com/@lexwill718',
5510 'uploader_id': '@lexwill718',
5511 'uploader': 'lex will',
5513 'playlist_mincount': 12,
5515 'note': 'Search tab',
5516 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5517 'playlist_mincount': 40,
5519 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5520 'title': '3Blue1Brown - Search - linear algebra',
5521 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5522 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5523 'tags': ['Mathematics'],
5524 'channel': '3Blue1Brown',
5525 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5526 'channel_follower_count': int,
5527 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5528 'uploader_id': '@3blue1brown',
5529 'uploader': '3Blue1Brown',
5532 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5533 'only_matching': True,
5535 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5536 'only_matching': True,
5538 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5539 'only_matching': True,
5541 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5542 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5544 'title': '29C3: Not my department',
5545 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5546 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5549 'modified_date': '20150605',
5550 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5551 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5552 'channel': 'Christiaan008',
5553 'availability': 'public',
5554 'uploader_id': '@ChRiStIaAn008',
5555 'uploader': 'Christiaan008',
5556 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5558 'playlist_count': 96,
5560 'note': 'Large playlist',
5561 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5563 'title': 'Uploads from Cauchemar',
5564 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5565 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5567 'modified_date': r
're:\d{8}',
5568 'channel': 'Cauchemar',
5571 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5572 'availability': 'public',
5573 'uploader_id': '@Cauchemar89',
5574 'uploader': 'Cauchemar',
5575 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5577 'playlist_mincount': 1123,
5578 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5580 'note': 'even larger playlist, 8832 videos',
5581 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5582 'only_matching': True,
5584 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5585 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5587 'title': 'Uploads from Interstellar Movie',
5588 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5591 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5592 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5593 'channel': 'Interstellar Movie',
5595 'modified_date': r
're:\d{8}',
5596 'availability': 'public',
5597 'uploader_id': '@InterstellarMovie',
5598 'uploader': 'Interstellar Movie',
5599 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5601 'playlist_mincount': 21,
5603 'note': 'Playlist with "show unavailable videos" button',
5604 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5606 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5607 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5609 'channel': 'Phim Siêu Nhân Nhật Bản',
5612 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5613 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5614 'modified_date': r
're:\d{8}',
5615 'availability': 'public',
5616 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5617 'uploader_id': '@phimsieunhannhatban',
5618 'uploader': 'Phim Siêu Nhân Nhật Bản',
5620 'playlist_mincount': 200,
5621 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5623 'note': 'Playlist with unavailable videos in page 7',
5624 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5626 'title': 'Uploads from BlankTV',
5627 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5628 'channel': 'BlankTV',
5629 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5630 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5633 'modified_date': r
're:\d{8}',
5635 'availability': 'public',
5636 'uploader_id': '@blanktv',
5637 'uploader': 'BlankTV',
5638 'uploader_url': 'https://www.youtube.com/@blanktv',
5640 'playlist_mincount': 1000,
5641 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5643 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5644 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5646 'title': 'Data Analysis with Dr Mike Pound',
5647 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5648 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5651 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5652 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5653 'channel': 'Computerphile',
5654 'availability': 'public',
5655 'modified_date': '20190712',
5656 'uploader_id': '@Computerphile',
5657 'uploader': 'Computerphile',
5658 'uploader_url': 'https://www.youtube.com/@Computerphile',
5660 'playlist_mincount': 11,
5662 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5663 'only_matching': True,
5665 'note': 'Playlist URL that does not actually serve a playlist',
5666 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5668 'id': 'FqZTN594JQw',
5670 'title': "Smiley's People 01 detective, Adventure Series, Action",
5671 'upload_date': '20150526',
5672 'license': 'Standard YouTube License',
5673 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5674 'categories': ['People & Blogs'],
5680 'skip_download': True,
5682 'skip': 'This video is not available.',
5683 'add_ie': [YoutubeIE
.ie_key()],
5685 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5686 'only_matching': True,
5688 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5689 'only_matching': True,
5691 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5693 'id': 'AlTsmyW4auo', # This will keep changing
5696 'upload_date': r
're:\d{8}',
5698 'categories': ['News & Politics'],
5701 'release_timestamp': int,
5702 'channel': 'Sky News',
5703 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5706 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5707 'playable_in_embed': True,
5708 'release_date': r
're:\d+',
5709 'availability': 'public',
5710 'live_status': 'is_live',
5711 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5712 'channel_follower_count': int,
5713 'concurrent_view_count': int,
5714 'uploader_url': 'https://www.youtube.com/@SkyNews',
5715 'uploader_id': '@SkyNews',
5716 'uploader': 'Sky News',
5719 'skip_download': True,
5721 'expected_warnings': ['Ignoring subtitle tracks found in '],
5723 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5725 'id': 'a48o2S1cPoo',
5727 'title': 'The Young Turks - Live Main Show',
5728 'upload_date': '20150715',
5729 'license': 'Standard YouTube License',
5730 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5731 'categories': ['News & Politics'],
5732 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5736 'skip_download': True,
5738 'only_matching': True,
5740 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5741 'only_matching': True,
5743 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5744 'only_matching': True,
5746 'note': 'A channel that is not live. Should raise error',
5747 'url': 'https://www.youtube.com/user/numberphile/live',
5748 'only_matching': True,
5750 'url': 'https://www.youtube.com/feed/trending',
5751 'only_matching': True,
5753 'url': 'https://www.youtube.com/feed/library',
5754 'only_matching': True,
5756 'url': 'https://www.youtube.com/feed/history',
5757 'only_matching': True,
5759 'url': 'https://www.youtube.com/feed/subscriptions',
5760 'only_matching': True,
5762 'url': 'https://www.youtube.com/feed/watch_later',
5763 'only_matching': True,
5765 'note': 'Recommended - redirects to home page.',
5766 'url': 'https://www.youtube.com/feed/recommended',
5767 'only_matching': True,
5769 'note': 'inline playlist with not always working continuations',
5770 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5771 'only_matching': True,
5773 'url': 'https://www.youtube.com/course',
5774 'only_matching': True,
5776 'url': 'https://www.youtube.com/zsecurity',
5777 'only_matching': True,
5779 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5780 'only_matching': True,
5782 'url': 'https://www.youtube.com/TheYoungTurks/live',
5783 'only_matching': True,
5785 'url': 'https://www.youtube.com/hashtag/cctv9',
5791 'playlist_mincount': 300, # not consistent but should be over 300
5793 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5794 'only_matching': True,
5796 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5797 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5798 'only_matching': True
5800 'note': '/browse/ should redirect to /channel/',
5801 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5802 'only_matching': True
5804 'note': 'VLPL, should redirect to playlist?list=PL...',
5805 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5807 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5808 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5809 'title': 'NCS : All Releases 💿',
5810 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5811 'modified_date': r
're:\d{8}',
5813 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5815 'channel': 'NoCopyrightSounds',
5816 'availability': 'public',
5817 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5818 'uploader': 'NoCopyrightSounds',
5819 'uploader_id': '@NoCopyrightSounds',
5821 'playlist_mincount': 166,
5822 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5824 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5825 'note': 'Topic, should redirect to playlist?list=UU...',
5826 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5828 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5829 'title': 'Uploads from Royalty Free Music - Topic',
5831 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5832 'channel': 'Royalty Free Music - Topic',
5834 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5835 'modified_date': r
're:\d{8}',
5837 'availability': 'public',
5838 'uploader': 'Royalty Free Music - Topic',
5840 'playlist_mincount': 101,
5841 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5843 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5844 # Treat as a general feed
5845 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5847 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5848 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5851 'playlist_mincount': 9,
5853 'note': 'Youtube music Album',
5854 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5856 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5857 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5861 'availability': 'unlisted',
5862 'modified_date': r
're:\d{8}',
5864 'playlist_count': 50,
5865 'expected_warnings': ['YouTube Music is not directly supported'],
5867 'note': 'unlisted single video playlist',
5868 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5870 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5871 'title': 'yt-dlp unlisted playlist test',
5872 'availability': 'unlisted',
5874 'modified_date': '20220418',
5875 'channel': 'colethedj',
5878 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5879 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5880 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5881 'uploader_id': '@colethedj1894',
5882 'uploader': 'colethedj',
5886 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5887 'id': 'BaW_jenozKc',
5889 'ie_key': 'Youtube',
5891 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5892 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5894 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5895 'channel': 'Philipp Hagemeister',
5896 'uploader_id': '@PhilippHagemeister',
5897 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
5898 'uploader': 'Philipp Hagemeister',
5901 'playlist_count': 1,
5902 'params': {'extract_flat': True}
,
5904 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5905 'url': 'https://www.youtube.com/feed/recommended',
5907 'id': 'recommended',
5908 'title': 'recommended',
5911 'playlist_mincount': 50,
5913 'skip_download': True,
5914 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5917 'note': 'API Fallback: /videos tab, sorted by oldest first',
5918 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5920 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5921 'title': 'Cody\'sLab - Videos',
5922 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5923 'channel': 'Cody\'sLab',
5924 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5926 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5927 'channel_follower_count': int
5929 'playlist_mincount': 650,
5931 'skip_download': True,
5932 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5934 'skip': 'Query for sorting no longer works',
5936 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5937 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5939 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5940 'title': 'Uploads from Royalty Free Music - Topic',
5941 'modified_date': r
're:\d{8}',
5942 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5944 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5946 'channel': 'Royalty Free Music - Topic',
5948 'availability': 'public',
5949 'uploader': 'Royalty Free Music - Topic',
5951 'playlist_mincount': 101,
5953 'skip_download': True,
5954 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5956 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5958 'note': 'non-standard redirect to regional channel',
5959 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5960 'only_matching': True
5962 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5963 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5965 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5966 'modified_date': '20220407',
5967 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5969 'availability': 'unlisted',
5970 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5971 'channel': 'pukkandan',
5972 'description': 'Test for collaborative playlist',
5973 'title': 'yt-dlp test - collaborative playlist',
5975 'uploader_url': 'https://www.youtube.com/@pukkandan',
5976 'uploader_id': '@pukkandan',
5977 'uploader': 'pukkandan',
5979 'playlist_mincount': 2
5981 'note': 'translated tab name',
5982 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
5984 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5986 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5987 'description': 'test description',
5988 'title': 'cole-dlp-test-acc - 再生リスト',
5989 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5990 'channel': 'cole-dlp-test-acc',
5991 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5992 'uploader_id': '@coletdjnz',
5993 'uploader': 'cole-dlp-test-acc',
5995 'playlist_mincount': 1,
5996 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5997 'expected_warnings': ['Preferring "ja"'],
5999 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6000 'note': 'preferred lang set with playlist with translated video titles',
6001 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6003 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6006 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6007 'channel': 'cole-dlp-test-acc',
6008 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6009 'description': 'test',
6010 'title': 'dlp test playlist',
6011 'availability': 'public',
6012 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6013 'uploader_id': '@coletdjnz',
6014 'uploader': 'cole-dlp-test-acc',
6016 'playlist_mincount': 1,
6017 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6018 'expected_warnings': ['Preferring "ja"'],
6020 # shorts audio pivot for 2GtVksBMYFM.
6021 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6023 'id': 'sfv_audio_pivot',
6024 'title': 'sfv_audio_pivot',
6027 'playlist_mincount': 50,
6030 # Channel with a real live tab (not to be mistaken with streams tab)
6031 # Do not treat like it should redirect to live stream
6032 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6034 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6035 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6038 'playlist_mincount': 20,
6040 # Tab name is not the same as tab id
6041 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6043 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6044 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6047 'playlist_mincount': 8,
6049 # Home tab id is literally home. Not to get mistaken with featured
6050 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6052 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6053 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6056 'playlist_mincount': 8,
6058 # Should get three playlists for videos, shorts and streams tabs
6059 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6061 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6062 'title': 'Polka Ch. 尾丸ポルカ',
6063 'channel_follower_count': int,
6064 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6065 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6066 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6067 'channel': 'Polka Ch. 尾丸ポルカ',
6069 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6070 'uploader': 'Polka Ch. 尾丸ポルカ',
6071 'uploader_id': '@OmaruPolka',
6073 'playlist_count': 3,
6075 # Shorts tab with channel with handle
6076 # TODO: fix channel description
6077 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6079 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6080 'title': 'Not Just Bikes - Shorts',
6082 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6083 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6084 'channel_follower_count': int,
6085 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6086 'channel': 'Not Just Bikes',
6087 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6088 'uploader': 'Not Just Bikes',
6089 'uploader_id': '@NotJustBikes',
6091 'playlist_mincount': 10,
6094 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6096 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6097 'title': '中村悠一 - Live',
6099 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6100 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6102 'channel_follower_count': int,
6103 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6104 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6105 'uploader_id': '@Yuichi-Nakamura',
6108 'playlist_mincount': 60,
6110 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6111 # See test_youtube_lists
6112 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6113 'only_matching': True,
6115 # No uploads and no UCID given. Should fail with no uploads error
6116 # See test_youtube_lists
6117 'url': 'https://www.youtube.com/news',
6118 'only_matching': True
6120 # No videos tab but has a shorts tab
6121 'url': 'https://www.youtube.com/c/TKFShorts',
6123 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6124 'title': 'Shorts Break - Shorts',
6126 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6127 'channel': 'Shorts Break',
6128 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6129 'channel_follower_count': int,
6130 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6131 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6132 'uploader': 'Shorts Break',
6133 'uploader_id': '@ShortsBreak_Official',
6135 'playlist_mincount': 30,
6137 # Trending Now Tab. tab id is empty
6138 'url': 'https://www.youtube.com/feed/trending',
6141 'title': 'trending - Now',
6144 'playlist_mincount': 30,
6146 # Trending Gaming Tab. tab id is empty
6147 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6150 'title': 'trending - Gaming',
6153 'playlist_mincount': 30,
6155 # Shorts url result in shorts tab
6156 # TODO: Fix channel id extraction
6157 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6159 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6160 'title': 'cole-dlp-test-acc - Shorts',
6161 'channel': 'cole-dlp-test-acc',
6162 'description': 'test description',
6163 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6164 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6166 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6167 'uploader_id': '@coletdjnz',
6168 'uploader': 'cole-dlp-test-acc',
6172 # Channel data is not currently available for short renderers (as of 2023-03-01)
6174 'ie_key': 'Youtube',
6175 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6176 'id': 'sSM9J5YH_60',
6177 'title': 'SHORT short',
6182 'params': {'extract_flat': True}
,
6184 # Live video status should be extracted
6185 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6187 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6188 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6194 'ie_key': 'Youtube',
6195 'url': 'startswith:https://www.youtube.com/watch?v=',
6198 'live_status': 'is_live',
6201 'concurrent_view_count': int,
6204 'uploader_url': str,
6208 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6209 'playlist_mincount': 1
6211 # Channel renderer metadata. Contains number of videos on the channel
6212 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6214 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6215 'title': 'cole-dlp-test-acc - Channels',
6216 'channel': 'cole-dlp-test-acc',
6217 'description': 'test description',
6218 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6219 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6221 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6222 'uploader_id': '@coletdjnz',
6223 'uploader': 'cole-dlp-test-acc',
6228 'ie_key': 'YoutubeTab',
6229 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6230 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6231 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6232 'title': 'PewDiePie',
6233 'channel': 'PewDiePie',
6234 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6236 'channel_follower_count': int,
6237 'playlist_count': int,
6238 'uploader': 'PewDiePie',
6239 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6240 'uploader_id': '@PewDiePie',
6243 'params': {'extract_flat': True}
,
6245 'url': 'https://www.youtube.com/@3blue1brown/about',
6247 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6248 'tags': ['Mathematics'],
6249 'title': '3Blue1Brown - About',
6250 'channel_follower_count': int,
6251 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6252 'channel': '3Blue1Brown',
6254 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6255 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6256 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6257 'uploader_id': '@3blue1brown',
6258 'uploader': '3Blue1Brown',
6260 'playlist_count': 0,
6262 # Podcasts tab, with rich entry playlistRenderers
6263 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6265 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6266 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6267 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6268 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6269 'title': '99 Percent Invisible - Podcasts',
6270 'uploader': '99 Percent Invisible',
6271 'channel_follower_count': int,
6272 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6274 'channel': '99 Percent Invisible',
6275 'uploader_id': '@99percentinvisiblepodcast',
6277 'playlist_count': 1,
6279 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6280 'url': 'https://www.youtube.com/@AHimitsu/releases',
6282 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6283 'channel': 'A Himitsu',
6284 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6285 'title': 'A Himitsu - Releases',
6286 'uploader_id': '@AHimitsu',
6287 'uploader': 'A Himitsu',
6288 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6290 'description': 'I make music',
6291 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6292 'channel_follower_count': int,
6294 'playlist_mincount': 10,
6298 def suitable(cls
, url
):
6299 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6301 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6303 def _get_url_mobj(self
, url
):
6304 mobj
= self
._URL
_RE
.match(url
).groupdict()
6305 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6308 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6309 tab_name
= (tab
.get('title') or '').lower()
6310 tab_url
= urljoin(base_url
, traverse_obj(
6311 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6313 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6314 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6317 'TAB_ID_SPONSORSHIPS': 'membership',
6318 }.get(tab_id
, tab_id
), tab_name
6320 # Fallback to tab name if we cannot get the tab id.
6321 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6322 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6324 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6328 }.get(tab_name
, tab_name
), tab_name
6330 def _has_tab(self
, tabs
, tab_id
):
6331 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6333 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6334 def _real_extract(self
, url
, smuggled_data
):
6335 item_id
= self
._match
_id
(url
)
6336 url
= urllib
.parse
.urlunparse(
6337 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6338 compat_opts
= self
.get_param('compat_opts', [])
6340 mobj
= self
._get
_url
_mobj
(url
)
6341 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6342 if is_channel
and smuggled_data
.get('is_music_url'):
6343 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6344 return self
.url_result(
6345 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6346 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6347 mdata
= self
._extract
_tab
_endpoint
(
6348 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6349 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6350 get_all
=False, expected_type
=str)
6352 raise ExtractorError('Failed to resolve album to playlist')
6353 return self
.url_result(murl
, YoutubeTabIE
)
6354 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6355 return self
.url_result(
6356 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6358 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6359 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6360 url
= f
'{pre}/videos{post}'
6361 if smuggled_data
.get('is_music_url'):
6362 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6364 # Handle both video/playlist URLs
6366 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6367 if not video_id
and mobj
['not_channel'].startswith('watch'):
6369 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6370 raise ExtractorError('A video URL was given without video ID', expected
=True)
6371 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6372 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6373 return self
.url_result(
6374 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6376 if not self
._yes
_playlist
(playlist_id
, video_id
):
6377 return self
.url_result(
6378 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6380 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6382 # YouTube may provide a non-standard redirect to the regional channel
6383 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6384 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6385 redirect_url
= traverse_obj(
6386 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6387 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6388 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6389 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6390 return self
.url_result(redirect_url
, YoutubeTabIE
)
6392 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6393 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6394 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6395 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6396 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6398 if not original_tab_id
and selected_tab_name
:
6399 self
.to_screen('Downloading all uploads of the channel. '
6400 'To download only the videos in a specific tab, pass the tab\'s URL')
6401 if self
._has
_tab
(tabs
, 'streams'):
6402 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6403 if self
._has
_tab
(tabs
, 'shorts'):
6404 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6405 # XXX: Members-only tab should also be extracted
6407 if not extra_tabs
and selected_tab_id
!= 'videos':
6408 # Channel does not have streams, shorts or videos tabs
6409 if item_id
[:2] != 'UC':
6410 raise ExtractorError('This channel has no uploads', expected
=True)
6412 # Topic channels don't have /videos. Use the equivalent playlist instead
6413 pl_id
= f
'UU{item_id[2:]}'
6414 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6416 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6417 except ExtractorError
:
6418 raise ExtractorError('This channel has no uploads', expected
=True)
6420 item_id
, url
= pl_id
, pl_url
6422 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6424 elif extra_tabs
and selected_tab_id
!= 'videos':
6425 # When there are shorts/live tabs but not videos tab
6426 url
, data
= f
'{pre}{post}', None
6428 elif (original_tab_id
or 'videos') != selected_tab_id
:
6429 if original_tab_id
== 'live':
6430 # Live tab should have redirected to the video
6431 # Except in the case the channel has an actual live tab
6432 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6433 raise UserNotLive(video_id
=item_id
)
6434 elif selected_tab_name
:
6435 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6437 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6438 url
= f
'{pre}{post}'
6440 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6441 if 'no-youtube-unavailable-videos' not in compat_opts
:
6442 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6443 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6445 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6447 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6449 'extractor_key': YoutubeTabIE
.ie_key(),
6450 'extractor': YoutubeTabIE
.IE_NAME
,
6453 if self
.get_param('playlist_items') == '0':
6454 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6455 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6456 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6458 if len(entries
) == 1:
6461 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6462 uploads_url
= 'the Uploads (UU) playlist URL'
6463 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6464 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6466 'Downloading as multiple playlists, separated by tabs. '
6467 f
'To download as a single playlist instead, pass {uploads_url}')
6468 return self
.playlist_result(entries
, item_id
, **metadata
)
6471 playlist
= traverse_obj(
6472 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6474 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6476 video_id
= traverse_obj(
6477 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6479 if tab
!= '/live': # live tab is expected to redirect to video
6480 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6481 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6483 raise ExtractorError('Unable to recognize tab page')
6486 class YoutubePlaylistIE(InfoExtractor
):
6487 IE_DESC
= 'YouTube playlists'
6488 _VALID_URL
= r
'''(?x)(?:
6493 youtube(?:kids)?\.com|
6498 (?P<id>%(playlist_id)s)
6500 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6501 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6503 IE_NAME
= 'youtube:playlist'
6505 'note': 'issue #673',
6506 'url': 'PLBB231211A4F62143',
6508 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6509 'id': 'PLBB231211A4F62143',
6510 'uploader': 'Wickman',
6511 'uploader_id': '@WickmanVT',
6512 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6514 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6515 'modified_date': r
're:\d{8}',
6516 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6517 'channel': 'Wickman',
6519 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6520 'availability': 'public',
6522 'playlist_mincount': 29,
6524 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6526 'title': 'YDL_safe_search',
6527 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6529 'playlist_count': 2,
6530 'skip': 'This playlist is private',
6533 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6534 'playlist_count': 4,
6537 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6538 'uploader': 'milan',
6539 'uploader_id': '@milan5503',
6541 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6543 'modified_date': '20140919',
6546 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6547 'uploader_url': 'https://www.youtube.com/@milan5503',
6548 'availability': 'public',
6550 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6552 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6553 'playlist_mincount': 455,
6555 'title': '2018 Chinese New Singles (11/6 updated)',
6556 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6558 'uploader_id': '@music_king',
6559 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6562 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6564 'uploader_url': 'https://www.youtube.com/@music_king',
6565 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6566 'modified_date': r
're:\d{8}',
6567 'availability': 'public',
6569 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6571 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6572 'only_matching': True,
6574 # music album playlist
6575 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6576 'only_matching': True,
6580 def suitable(cls
, url
):
6581 if YoutubeTabIE
.suitable(url
):
6583 from ..utils
import parse_qs
6585 if qs
.get('v', [None])[0]:
6587 return super().suitable(url
)
6589 def _real_extract(self
, url
):
6590 playlist_id
= self
._match
_id
(url
)
6591 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6592 url
= update_url_query(
6593 'https://www.youtube.com/playlist',
6594 parse_qs(url
) or {'list': playlist_id}
)
6596 url
= smuggle_url(url
, {'is_music_url': True}
)
6597 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6600 class YoutubeYtBeIE(InfoExtractor
):
6601 IE_DESC
= 'youtu.be'
6602 _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}
6604 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6606 'id': 'yeWKywCrFtk',
6608 'title': 'Small Scale Baler and Braiding Rugs',
6609 'uploader': 'Backus-Page House Museum',
6610 'uploader_id': '@backuspagemuseum',
6611 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6612 'upload_date': '20161008',
6613 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6614 'categories': ['Nonprofits & Activism'],
6618 'playable_in_embed': True,
6619 'thumbnail': r
're:^https?://.*\.webp',
6620 'channel': 'Backus-Page House Museum',
6621 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6622 'live_status': 'not_live',
6624 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6625 'availability': 'public',
6627 'comment_count': int,
6628 'channel_follower_count': int
6632 'skip_download': True,
6635 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6636 'only_matching': True,
6639 def _real_extract(self
, url
):
6640 mobj
= self
._match
_valid
_url
(url
)
6641 video_id
= mobj
.group('id')
6642 playlist_id
= mobj
.group('playlist_id')
6643 return self
.url_result(
6644 update_url_query('https://www.youtube.com/watch', {
6646 'list': playlist_id
,
6647 'feature': 'youtu.be',
6648 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6651 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6652 IE_DESC
= 'YouTube livestream embeds'
6653 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6655 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6656 'only_matching': True,
6659 def _real_extract(self
, url
):
6660 channel_id
= self
._match
_id
(url
)
6661 return self
.url_result(
6662 f
'https://www.youtube.com/channel/{channel_id}/live',
6663 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6666 class YoutubeYtUserIE(InfoExtractor
):
6667 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6668 IE_NAME
= 'youtube:user'
6669 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6671 'url': 'ytuser:phihag',
6672 'only_matching': True,
6675 def _real_extract(self
, url
):
6676 user_id
= self
._match
_id
(url
)
6677 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6680 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6681 IE_NAME
= 'youtube:favorites'
6682 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6683 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6684 _LOGIN_REQUIRED
= True
6687 'only_matching': True,
6689 'url': ':ytfavorites',
6690 'only_matching': True,
6693 def _real_extract(self
, url
):
6694 return self
.url_result(
6695 'https://www.youtube.com/playlist?list=LL',
6696 ie
=YoutubeTabIE
.ie_key())
6699 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6700 IE_NAME
= 'youtube:notif'
6701 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6702 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6703 _LOGIN_REQUIRED
= True
6706 'only_matching': True,
6708 'url': ':ytnotifications',
6709 'only_matching': True,
6712 def _extract_notification_menu(self
, response
, continuation_list
):
6713 notification_list
= traverse_obj(
6715 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6716 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6717 expected_type
=list) or []
6718 continuation_list
[0] = None
6719 for item
in notification_list
:
6720 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6723 continuation
= item
.get('continuationItemRenderer')
6725 continuation_list
[0] = continuation
6727 def _extract_notification_renderer(self
, notification
):
6728 video_id
= traverse_obj(
6729 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6730 url
= f
'https://www.youtube.com/watch?v={video_id}'
6733 browse_ep
= traverse_obj(
6734 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6735 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6736 post_id
= self
._search
_regex
(
6737 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6738 'post id', default
=None)
6739 if not channel_id
or not post_id
:
6741 # The direct /post url redirects to this in the browser
6742 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6744 channel
= traverse_obj(
6745 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6747 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6748 if notification_title
:
6749 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6750 # TODO: handle recommended videos
6751 title
= self
._search
_regex
(
6752 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6753 'video title', default
=None)
6754 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6755 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6760 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6761 'video_id': video_id
,
6763 'channel_id': channel_id
,
6765 'uploader': channel
,
6766 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6767 'timestamp': timestamp
,
6770 def _notification_menu_entries(self
, ytcfg
):
6771 continuation_list
= [None]
6773 for page
in itertools
.count(1):
6774 ctoken
= traverse_obj(
6775 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6776 response
= self
._extract
_response
(
6777 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6778 ep
='notification/get_notification_menu', check_get_keys
='actions',
6779 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6780 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6781 if not continuation_list
[0]:
6784 def _real_extract(self
, url
):
6785 display_id
= 'notifications'
6786 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6787 self
._report
_playlist
_authcheck
(ytcfg
)
6788 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6791 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6792 IE_DESC
= 'YouTube search'
6793 IE_NAME
= 'youtube:search'
6794 _SEARCH_KEY
= 'ytsearch'
6795 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6797 'url': 'ytsearch5:youtube-dl test video',
6798 'playlist_count': 5,
6800 'id': 'youtube-dl test video',
6801 'title': 'youtube-dl test video',
6806 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6807 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6808 _SEARCH_KEY
= 'ytsearchdate'
6809 IE_DESC
= 'YouTube search, newest videos first'
6810 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6812 'url': 'ytsearchdate5:youtube-dl test video',
6813 'playlist_count': 5,
6815 'id': 'youtube-dl test video',
6816 'title': 'youtube-dl test video',
6821 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6822 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6823 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6824 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6826 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6827 'playlist_mincount': 5,
6829 'id': 'youtube-dl test video',
6830 'title': 'youtube-dl test video',
6833 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6834 'playlist_mincount': 5,
6840 'url': 'https://www.youtube.com/results?search_query=%23cats',
6841 'playlist_mincount': 1,
6845 # The test suite does not have support for nested playlists
6847 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6853 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6856 'title': 'kurzgesagt',
6861 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6862 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6863 'ie_key': 'YoutubeTab',
6864 'channel': 'Kurzgesagt – In a Nutshell',
6865 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6866 'title': 'Kurzgesagt – In a Nutshell',
6867 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6868 'playlist_count': int, # XXX: should have a way of saying > 1
6869 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6871 'uploader_id': '@kurzgesagt',
6872 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6873 'uploader': 'Kurzgesagt – In a Nutshell',
6876 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6877 'playlist_mincount': 1,
6879 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6880 'only_matching': True,
6883 def _real_extract(self
, url
):
6885 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6886 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6889 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6890 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6891 IE_NAME
= 'youtube:music:search_url'
6892 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6894 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6895 'playlist_count': 16,
6897 'id': 'royalty free music',
6898 'title': 'royalty free music',
6901 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6902 'playlist_mincount': 30,
6904 'id': 'royalty free music - songs',
6905 'title': 'royalty free music - songs',
6907 'params': {'extract_flat': 'in_playlist'}
6909 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6910 'playlist_mincount': 30,
6912 'id': 'royalty free music - community playlists',
6913 'title': 'royalty free music - community playlists',
6915 'params': {'extract_flat': 'in_playlist'}
6919 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6920 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6921 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6922 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6923 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6924 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6927 def _real_extract(self
, url
):
6929 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6930 params
= qs
.get('sp', (None,))[0]
6932 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6934 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6935 params
= self
._SECTIONS
.get(section
)
6938 title
= join_nonempty(query
, section
, delim
=' - ')
6939 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6942 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6944 Base class for feed extractors
6945 Subclasses must re-define the _FEED_NAME property.
6947 _LOGIN_REQUIRED
= True
6948 _FEED_NAME
= 'feeds'
6950 def _real_initialize(self
):
6951 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6955 return f
'youtube:{self._FEED_NAME}'
6957 def _real_extract(self
, url
):
6958 return self
.url_result(
6959 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6962 class YoutubeWatchLaterIE(InfoExtractor
):
6963 IE_NAME
= 'youtube:watchlater'
6964 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
6965 _VALID_URL
= r
':ytwatchlater'
6967 'url': ':ytwatchlater',
6968 'only_matching': True,
6971 def _real_extract(self
, url
):
6972 return self
.url_result(
6973 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
6976 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
6977 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
6978 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
6979 _FEED_NAME
= 'recommended'
6980 _LOGIN_REQUIRED
= False
6983 'only_matching': True,
6985 'url': ':ytrecommended',
6986 'only_matching': True,
6988 'url': 'https://youtube.com',
6989 'only_matching': True,
6993 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
6994 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
6995 _VALID_URL
= r
':ytsub(?:scription)?s?'
6996 _FEED_NAME
= 'subscriptions'
6999 'only_matching': True,
7001 'url': ':ytsubscriptions',
7002 'only_matching': True,
7006 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7007 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7008 _VALID_URL
= r
':ythis(?:tory)?'
7009 _FEED_NAME
= 'history'
7011 'url': ':ythistory',
7012 'only_matching': True,
7016 class YoutubeStoriesIE(InfoExtractor
):
7017 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
7018 IE_NAME
= 'youtube:stories'
7019 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
7021 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
7022 'only_matching': True,
7025 def _real_extract(self
, url
):
7026 playlist_id
= f
'RLTD{self._match_id(url)}'
7027 return self
.url_result(
7028 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
7029 ie
=YoutubeTabIE
, video_id
=playlist_id
)
7032 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7033 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7034 IE_NAME
= 'youtube:shorts:pivot:audio'
7035 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7037 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7038 'only_matching': True,
7042 def _generate_audio_pivot_params(video_id
):
7044 Generates sfv_audio_pivot browse params for this video id
7046 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7047 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7049 def _real_extract(self
, url
):
7050 video_id
= self
._match
_id
(url
)
7051 return self
.url_result(
7052 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7056 class YoutubeTruncatedURLIE(InfoExtractor
):
7057 IE_NAME
= 'youtube:truncated_url'
7058 IE_DESC
= False # Do not list
7059 _VALID_URL
= r
'''(?x)
7061 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7064 annotation_id=annotation_[^&]+|
7070 attribution_link\?a=[^&]+
7076 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7077 'only_matching': True,
7079 'url': 'https://www.youtube.com/watch?',
7080 'only_matching': True,
7082 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7083 'only_matching': True,
7085 'url': 'https://www.youtube.com/watch?feature=foo',
7086 'only_matching': True,
7088 'url': 'https://www.youtube.com/watch?hl=en-GB',
7089 'only_matching': True,
7091 'url': 'https://www.youtube.com/watch?t=2372',
7092 'only_matching': True,
7095 def _real_extract(self
, url
):
7096 raise ExtractorError(
7097 'Did you forget to quote the URL? Remember that & is a meta '
7098 'character in most shells, so you want to put the URL in quotes, '
7100 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7101 ' or simply youtube-dl BaW_jenozKc .',
7105 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7106 IE_NAME
= 'youtube:clip'
7107 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7109 # FIXME: Other metadata should be extracted from the clip, not from the base video
7110 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7112 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7114 'section_start': 29.0,
7115 'section_end': 39.7,
7118 'availability': 'public',
7119 'categories': ['Gaming'],
7120 'channel': 'Scott The Woz',
7121 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7122 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7123 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7125 'playable_in_embed': True,
7127 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7128 'title': 'Mobile Games on Console - Scott The Woz',
7129 'upload_date': '20210920',
7130 'uploader': 'Scott The Woz',
7131 'uploader_id': '@ScottTheWoz',
7132 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7134 'live_status': 'not_live',
7135 'channel_follower_count': int,
7136 'chapters': 'count:20',
7140 def _real_extract(self
, url
):
7141 clip_id
= self
._match
_id
(url
)
7142 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7144 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7146 raise ExtractorError('Unable to find video ID')
7148 clip_data
= traverse_obj(data
, (
7149 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7150 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7151 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7152 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7155 '_type': 'url_transparent',
7156 'url': f
'https://www.youtube.com/watch?v={video_id}',
7157 'ie_key': YoutubeIE
.ie_key(),
7159 'section_start': int(clip_data
['startTimeMs']) / 1000,
7160 'section_end': int(clip_data
['endTimeMs']) / 1000,
7164 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7165 IE_NAME
= 'youtube:consent'
7166 IE_DESC
= False # Do not list
7167 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7169 'url': 'https://consent.youtube.com/m?continue=https%3A%2F%2Fwww.youtube.com%2Flive%2FqVv6vCqciTM%3Fcbrd%3D1&gl=NL&m=0&pc=yt&hl=en&src=1',
7171 'id': 'qVv6vCqciTM',
7174 'uploader_id': '@sana_natori',
7175 'comment_count': int,
7176 'chapters': 'count:13',
7177 'upload_date': '20221223',
7178 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7179 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7180 'uploader_url': 'https://www.youtube.com/@sana_natori',
7182 'release_date': '20221223',
7183 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7184 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7186 'playable_in_embed': True,
7188 'availability': 'public',
7189 'channel_follower_count': int,
7190 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7191 'categories': ['Entertainment'],
7192 'live_status': 'was_live',
7193 'release_timestamp': 1671793345,
7194 'channel': 'さなちゃんねる',
7195 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7196 'uploader': 'さなちゃんねる',
7198 'add_ie': ['Youtube'],
7199 'params': {'skip_download': 'Youtube'}
,
7202 def _real_extract(self
, url
):
7203 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7204 if not redirect_url
:
7205 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7206 return self
.url_result(redirect_url
)
7209 class YoutubeTruncatedIDIE(InfoExtractor
):
7210 IE_NAME
= 'youtube:truncated_id'
7211 IE_DESC
= False # Do not list
7212 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7215 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7216 'only_matching': True,
7219 def _real_extract(self
, url
):
7220 video_id
= self
._match
_id
(url
)
7221 raise ExtractorError(
7222 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',