mirror
/
yt-dlc
mirror of https://github.com/blackjack4494/yt-dlc.git
1
0
Fork 0
Code Issues Releases Wiki Activity

[youtube] Extract data from multiple clients (#536) 

* `player_client` accepts multiple clients
* default `player_client` = `android,web`
* music clients can be specifically requested
* Add IOS `player_client`
* Hide live dash since they can't be downloaded

Closes #501

Authored-by: pukkandan, colethedj
This commit is contained in:
pukkandan 2021-07-21 09:22:34 +05:30 committed by GitHub
parent c84aeac6b5
commit 11f9be0912
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 393 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -1337,8 +1337,8 @@ Some extractors accept additional arguments which can be passed using `--extract
The following extractors use this feature:
* **youtube**
* `skip`: `hls` or `dash` (or both) to skip download of the respective manifests
* `player_client`: `web` (default) or `android` (force use the android client fallbacks for video extraction)
* `player_skip`: `configs` - skip requests if applicable for client configs and use defaults
* `player_client`: Clients to extract video data from - one or more of `web`, `android`, `ios`, `web_music`, `android_music`, `ios_music`. By default, `android,web` is used. If the URL is from `music.youtube.com`, `android,web,android_music,web_music` is used
* `player_skip`: `configs` - skip any requests for client configs and use defaults
* `comment_sort`: `top` or `new` (default) - choose comment sorting mode (on YouTube's side).
* `max_comments`: maximum amount of comments to download (default all).
* `max_comment_depth`: maximum depth for nested comments. YouTube supports depths 1 or 2 (default).

8
yt_dlp/downloader/youtube_live_chat.py
View File

@ -116,7 +116,7 @@ class YoutubeLiveChatFD(FragmentFD):
if not success:
return False, None, None, None
try:
data = ie._extract_yt_initial_data(video_id, raw_fragment.decode('utf-8', 'replace'))
data = ie.extract_yt_initial_data(video_id, raw_fragment.decode('utf-8', 'replace'))
except RegexNotFoundError:
data = None
if not data:
@ -146,7 +146,7 @@ class YoutubeLiveChatFD(FragmentFD):
if not success:
return False
try:
data = ie._extract_yt_initial_data(video_id, raw_fragment.decode('utf-8', 'replace'))
data = ie.extract_yt_initial_data(video_id, raw_fragment.decode('utf-8', 'replace'))
except RegexNotFoundError:
return False
continuation_id = try_get(
@ -155,7 +155,7 @@ class YoutubeLiveChatFD(FragmentFD):
# no data yet but required to call _append_fragment
self._append_fragment(ctx, b'')
ytcfg = ie._extract_ytcfg(video_id, raw_fragment.decode('utf-8', 'replace'))
ytcfg = ie.extract_ytcfg(video_id, raw_fragment.decode('utf-8', 'replace'))
if not ytcfg:
return False
@ -183,7 +183,7 @@ class YoutubeLiveChatFD(FragmentFD):
request_data['currentPlayerState'] = {'playerOffsetMs': str(max(offset - 5000, 0))}
if click_tracking_params:
request_data['context']['clickTracking'] = {'clickTrackingParams': click_tracking_params}
headers = ie._generate_api_headers(ytcfg, visitor_data=visitor_data)
headers = ie.generate_api_headers(ytcfg, visitor_data=visitor_data)
headers.update({'content-type': 'application/json'})
fragment_request_data = json.dumps(request_data, ensure_ascii=False).encode('utf-8') + b'\n'
success, continuation_id, offset, click_tracking_params = download_and_parse_fragment(

645
yt_dlp/extractor/youtube.py
View File

@ -28,18 +28,18 @@ from ..compat import (
)
from ..jsinterp import JSInterpreter
from ..utils import (
bool_or_none,
bytes_to_intlist,
clean_html,
dict_get,
datetime_from_str,
dict_get,
error_to_compat_str,
ExtractorError,
format_field,
float_or_none,
format_field,
int_or_none,
intlist_to_bytes,
mimetype2ext,
orderedSet,
parse_codecs,
parse_count,
parse_duration,
@ -392,6 +392,49 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
}
},
'INNERTUBE_CONTEXT_CLIENT_NAME': 21
},
'IOS': {
'INNERTUBE_API_VERSION': 'v1',
'INNERTUBE_CLIENT_NAME': 'IOS',
'INNERTUBE_CLIENT_VERSION': '16.20',
'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
'INNERTUBE_CONTEXT': {
'client': {
'clientName': 'IOS',
'clientVersion': '16.20',
'hl': 'en',
}
},
'INNERTUBE_CONTEXT_CLIENT_NAME': 5
},
'IOS_MUSIC': {
'INNERTUBE_API_VERSION': 'v1',
'INNERTUBE_CLIENT_NAME': 'IOS_MUSIC',
'INNERTUBE_CLIENT_VERSION': '4.32',
'INNERTUBE_API_KEY': 'AIzaSyDK3iBpDP9nHVTk2qL73FLJICfOC3c51Og',
'INNERTUBE_CONTEXT': {
'client': {
'clientName': 'IOS_MUSIC',
'clientVersion': '4.32',
'hl': 'en',
}
},
'INNERTUBE_CONTEXT_CLIENT_NAME': 26
},
'IOS_MESSAGES_EXTENSION': {
'INNERTUBE_API_VERSION': 'v1',
'INNERTUBE_CLIENT_NAME': 'IOS_MESSAGES_EXTENSION',
'INNERTUBE_CLIENT_VERSION': '16.20',
'INNERTUBE_API_KEY': 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8',
'INNERTUBE_CONTEXT': {
'client': {
'clientName': 'IOS_MESSAGES_EXTENSION',
'clientVersion': '16.20',
'hl': 'en',
}
},
'INNERTUBE_CONTEXT_CLIENT_NAME': 66
}
}
@ -402,6 +445,22 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
'ANDROID_MUSIC': 'music.youtube.com'
}
# clients starting with _ cannot be explicity requested by the user
_YT_CLIENTS = {
'web': 'WEB',
'web_music': 'WEB_REMIX',
'_web_embedded': 'WEB_EMBEDDED_PLAYER',
'_web_agegate': 'TVHTML5',
'android': 'ANDROID',
'android_music': 'ANDROID_MUSIC',
'_android_embedded': 'ANDROID_EMBEDDED_PLAYER',
'_android_agegate': 'ANDROID',
'ios': 'IOS',
'ios_music': 'IOS_MUSIC',
'_ios_embedded': 'IOS_MESSAGES_EXTENSION',
'_ios_agegate': 'IOS'
}
def _get_default_ytcfg(self, client='WEB'):
if client in self._YT_DEFAULT_YTCFGS:
return copy.deepcopy(self._YT_DEFAULT_YTCFGS[client])
@ -420,8 +479,11 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CLIENT_NAME'], compat_str, default_client)
@staticmethod
def _extract_session_index(ytcfg):
return int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
def _extract_session_index(*data):
for ytcfg in data:
session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
if session_index is not None:
return session_index
def _extract_client_version(self, ytcfg, default_client='WEB'):
return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CLIENT_VERSION'], compat_str, default_client)
@ -473,7 +535,7 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
data.update(query)
real_headers = self._generate_api_headers(client=default_client)
real_headers = self.generate_api_headers(default_client=default_client)
real_headers.update({'content-type': 'application/json'})
if headers:
real_headers.update(headers)
@ -483,7 +545,7 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
data=json.dumps(data).encode('utf8'), headers=real_headers,
query={'key': api_key or self._extract_api_key()})
def _extract_yt_initial_data(self, video_id, webpage):
def extract_yt_initial_data(self, video_id, webpage):
return self._parse_json(
self._search_regex(
(r'%s\s*%s' % (self._YT_INITIAL_DATA_RE, self._YT_INITIAL_BOUNDARY_RE),
@ -491,7 +553,9 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
video_id)
def _extract_identity_token(self, webpage, item_id):
ytcfg = self._extract_ytcfg(item_id, webpage)
if not webpage:
return None
ytcfg = self.extract_ytcfg(item_id, webpage)
if ytcfg:
token = try_get(ytcfg, lambda x: x['ID_TOKEN'], compat_str)
if token:
@ -519,7 +583,7 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
# and just "user_syncid||" for primary channel. We only want the channel_syncid
return sync_ids[0]
def _extract_ytcfg(self, video_id, webpage):
def extract_ytcfg(self, video_id, webpage):
if not webpage:
return {}
return self._parse_json(
@ -527,18 +591,19 @@ class YoutubeBaseInfoExtractor(InfoExtractor):
r'ytcfg\.set\s*\(\s*({.+?})\s*\)\s*;', webpage, 'ytcfg',
default='{}'), video_id, fatal=False) or {}
def _generate_api_headers(self, ytcfg=None, identity_token=None, account_syncid=None,
visitor_data=None, api_hostname=None, client='WEB', session_index=None):
origin = 'https://' + (api_hostname if api_hostname else self._get_innertube_host(client))
def generate_api_headers(
self, ytcfg=None, identity_token=None, account_syncid=None,
visitor_data=None, api_hostname=None, default_client='WEB', session_index=None):
origin = 'https://' + (api_hostname if api_hostname else self._get_innertube_host(default_client))
headers = {
'X-YouTube-Client-Name': compat_str(
self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client=client)),
'X-YouTube-Client-Version': self._extract_client_version(ytcfg, client),
self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client=default_client)),
'X-YouTube-Client-Version': self._extract_client_version(ytcfg, default_client),
'Origin': origin
}
if not visitor_data and ytcfg:
visitor_data = try_get(
self._extract_context(ytcfg, client), lambda x: x['client']['visitorData'], compat_str)
self._extract_context(ytcfg, default_client), lambda x: x['client']['visitorData'], compat_str)
if identity_token:
headers['X-Youtube-Identity-Token'] = identity_token
if account_syncid:
@ -1122,7 +1187,7 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'uploader_id': 'olympic',
'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/olympic',
'description': 'HO09 - Women - GER-AUS - Hockey - 31 July 2012 - London 2012 Olympic Games',
'uploader': 'Olympic',
'uploader': 'Olympics',
'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
},
'params': {
@ -1287,16 +1352,16 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'id': 'lsguqyKfVQg',
'ext': 'mp4',
'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
'alt_title': 'Dark Walk - Position Music',
'alt_title': 'Dark Walk',
'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
'duration': 133,
'upload_date': '20151119',
'uploader_id': 'IronSoulElf',
'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/IronSoulElf',
'uploader': 'IronSoulElf',
'creator': 'Todd Haberman, Daniel Law Heath and Aaron Kaplan',
'track': 'Dark Walk - Position Music',
'artist': 'Todd Haberman, Daniel Law Heath and Aaron Kaplan',
'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
'track': 'Dark Walk',
'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
},
'params': {
@ -1615,6 +1680,7 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'title': 'San Diego teen commits suicide after bullying over embarrassing video',
'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
'uploader': 'CBS This Morning',
'uploader_id': 'CBSThisMorning',
'upload_date': '20140716',
'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7'
}
@ -1652,13 +1718,14 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
'info_dict': {
'id': 'YOelRv7fMxY',
'title': 'Digging a Secret Tunnel from my Workshop',
'title': 'DIGGING A SECRET TUNNEL Part 1',
'ext': '3gp',
'upload_date': '20210624',
'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
'uploader': 'colinfurze',
'uploader_id': 'colinfurze',
'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
'description': 'md5:ecb672623246d98c6c562eed6ae798c3'
'description': 'md5:b5096f56af7ccd7a555c84db81738b22'
},
'params': {
'format': '17', # 3gp format available on android
@ -1692,10 +1759,12 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
def _extract_player_url(self, ytcfg=None, webpage=None):
player_url = try_get(ytcfg, (lambda x: x['PLAYER_JS_URL']), str)
if not player_url:
if not player_url and webpage:
player_url = self._search_regex(
r'"(?:PLAYER_JS_URL|jsUrl)"\s*:\s*"([^"]+)"',
webpage, 'player URL', fatal=False)
if not player_url:
return None
if player_url.startswith('//'):
player_url = 'https:' + player_url
elif not re.match(r'https?://', player_url):
@ -1859,10 +1928,10 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'JS player signature timestamp', group='sts', fatal=fatal))
return sts
def _mark_watched(self, video_id, player_response):
playback_url = url_or_none(try_get(
player_response,
lambda x: x['playbackTracking']['videostatsPlaybackUrl']['baseUrl']))
def _mark_watched(self, video_id, player_responses):
playback_url = url_or_none((traverse_obj(
player_responses, ('playbackTracking', 'videostatsPlaybackUrl', 'baseUrl'),
expected_type=str) or [None])[0])
if not playback_url:
return
parsed_playback_url = compat_urlparse.urlparse(playback_url)
@ -2122,7 +2191,7 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
for page_num in itertools.count(0):
if not continuation:
break
headers = self._generate_api_headers(ytcfg, identity_token, account_syncid, visitor_data)
headers = self.generate_api_headers(ytcfg, identity_token, account_syncid, visitor_data)
comment_prog_str = '(%d/%d)' % (comment_counts[0], comment_counts[1])
if page_num == 0:
if is_first_continuation:
@ -2277,6 +2346,10 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'TVHTML5': {
'c': 'TVHTML5',
'cver': '6.20180913',
},
'IOS': {
'c': 'IOS',
'cver': '16.20'
}
}
query = {
@ -2287,215 +2360,111 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
query.update(GVI_CLIENTS.get(client))
return query
def _real_extract(self, url):
url, smuggled_data = unsmuggle_url(url, {})
video_id = self._match_id(url)
def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, identity_token, player_url, initial_pr):
is_music_url = smuggled_data.get('is_music_url') or self.is_music_url(url)
base_url = self.http_scheme() + '//www.youtube.com/'
webpage_url = base_url + 'watch?v=' + video_id
webpage = self._download_webpage(
webpage_url + '&bpctr=9999999999&has_verified=1', video_id, fatal=False)
ytcfg = self._extract_ytcfg(video_id, webpage) or self._get_default_ytcfg()
identity_token = self._extract_identity_token(webpage, video_id)
session_index = self._extract_session_index(ytcfg)
player_url = self._extract_player_url(ytcfg, webpage)
player_client = self._configuration_arg('player_client', [''])[0]
if player_client not in ('web', 'android', ''):
self.report_warning(f'Invalid player_client {player_client} given. Falling back to android client.')
force_mobile_client = player_client != 'web'
player_skip = self._configuration_arg('player_skip')
player_response = None
if webpage:
player_response = self._extract_yt_initial_variable(
webpage, self._YT_INITIAL_PLAYER_RESPONSE_RE,
video_id, 'initial player response')
syncid = self._extract_account_syncid(ytcfg, player_response)
headers = self._generate_api_headers(ytcfg, identity_token, syncid, session_index=session_index)
ytm_streaming_data = {}
if is_music_url:
ytm_webpage = None
sts = self._extract_signature_timestamp(video_id, player_url, ytcfg, fatal=False)
if sts and not force_mobile_client and 'configs' not in player_skip:
ytm_webpage = self._download_webpage(
'https://music.youtube.com',
video_id, fatal=False, note='Downloading remix client config')
ytm_cfg = self._extract_ytcfg(video_id, ytm_webpage) or {}
ytm_client = 'WEB_REMIX'
if not sts or force_mobile_client:
# Android client already has signature descrambled
# See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/562
if not sts:
self.report_warning('Falling back to android remix client for player API.')
ytm_client = 'ANDROID_MUSIC'
ytm_cfg = {}
ytm_headers = self._generate_api_headers(
ytm_cfg, identity_token, syncid,
client=ytm_client, session_index=session_index)
ytm_query = {'videoId': video_id}
ytm_query.update(self._generate_player_context(sts))
ytm_player_response = self._extract_response(
item_id=video_id, ep='player', query=ytm_query,
ytcfg=ytm_cfg, headers=ytm_headers, fatal=False,
default_client=ytm_client,
note='Downloading %sremix player API JSON' % ('android ' if force_mobile_client else ''))
ytm_streaming_data = try_get(ytm_player_response, lambda x: x['streamingData'], dict) or {}
if not player_response or force_mobile_client:
sts = self._extract_signature_timestamp(video_id, player_url, ytcfg, fatal=False)
yt_client = 'WEB'
ytpcfg = ytcfg
ytp_headers = headers
if not sts or force_mobile_client:
# Android client already has signature descrambled
# See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/562
if not sts:
self.report_warning('Falling back to android client for player API.')
yt_client = 'ANDROID'
ytpcfg = {}
ytp_headers = self._generate_api_headers(ytpcfg, identity_token, syncid,
client=yt_client, session_index=session_index)
session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False)
headers = self.generate_api_headers(
player_ytcfg, identity_token, syncid,
default_client=self._YT_CLIENTS[client], session_index=session_index)
yt_query = {'videoId': video_id}
yt_query.update(self._generate_player_context(sts))
player_response = self._extract_response(
return self._extract_response(
item_id=video_id, ep='player', query=yt_query,
ytcfg=ytpcfg, headers=ytp_headers, fatal=False,
default_client=yt_client,
note='Downloading %splayer API JSON' % ('android ' if force_mobile_client else '')
) or player_response
ytcfg=player_ytcfg, headers=headers, fatal=False,
default_client=self._YT_CLIENTS[client],
note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
) or None
# Age-gate workarounds
playability_status = player_response.get('playabilityStatus') or {}
if playability_status.get('reason') in self._AGE_GATE_REASONS:
gvi_clients = ('ANDROID', 'TVHTML5') if force_mobile_client else ('TVHTML5', 'ANDROID')
for gvi_client in gvi_clients:
pr = self._parse_json(try_get(compat_parse_qs(
self._download_webpage(
base_url + 'get_video_info', video_id,
def _extract_age_gated_player_response(self, client, video_id, ytcfg, identity_token, player_url, initial_pr):
gvi_client = self._YT_CLIENTS.get(f'_{client}_agegate')
if not gvi_client:
return
pr = self._parse_json(traverse_obj(
compat_parse_qs(self._download_webpage(
self.http_scheme() + '//www.youtube.com/get_video_info', video_id,
'Refetching age-gated %s info webpage' % gvi_client.lower(),
'unable to download video info webpage', fatal=False,
query=self._get_video_info_params(video_id, client=gvi_client))),
lambda x: x['player_response'][0],
compat_str) or '{}', video_id)
('player_response', 0), expected_type=str) or '{}', video_id)
if pr:
break
if not pr:
self.report_warning('Falling back to embedded-only age-gate workaround.')
return pr
self.report_warning('Falling back to embedded-only age-gate workaround')
embed_webpage = None
sts = self._extract_signature_timestamp(video_id, player_url, ytcfg, fatal=False)
if sts and not force_mobile_client and 'configs' not in player_skip:
if client == 'web' and 'configs' not in self._configuration_arg('player_skip'):
embed_webpage = self._download_webpage(
'https://www.youtube.com/embed/%s?html5=1' % video_id,
video_id=video_id, note='Downloading age-gated embed config')
video_id=video_id, note=f'Downloading age-gated {client} embed config')
ytcfg_age = self._extract_ytcfg(video_id, embed_webpage) or {}
ytcfg_age = self.extract_ytcfg(video_id, embed_webpage) or {}
# If we extracted the embed webpage, it'll tell us if we can view the video
embedded_pr = self._parse_json(
try_get(ytcfg_age, lambda x: x['PLAYER_VARS']['embedded_player_response'], str) or '{}',
traverse_obj(ytcfg_age, ('PLAYER_VARS', 'embedded_player_response'), expected_type=str) or '{}',
video_id=video_id)
embedded_ps_reason = try_get(embedded_pr, lambda x: x['playabilityStatus']['reason'], str) or ''
if embedded_ps_reason not in self._AGE_GATE_REASONS:
yt_client = 'WEB_EMBEDDED_PLAYER'
if not sts or force_mobile_client:
# Android client already has signature descrambled
# See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/562
if not sts:
self.report_warning(
'Falling back to android embedded client for player API (note: some formats may be missing).')
yt_client = 'ANDROID_EMBEDDED_PLAYER'
ytcfg_age = {}
embedded_ps_reason = traverse_obj(embedded_pr, ('playabilityStatus', 'reason'), expected_type=str) or ''
if embedded_ps_reason in self._AGE_GATE_REASONS:
return
return self._extract_player_response(
f'_{client}_embedded', video_id,
ytcfg_age or ytcfg, ytcfg_age if client == 'web' else {},
identity_token, player_url, initial_pr)
ytage_headers = self._generate_api_headers(
ytcfg_age, identity_token, syncid,
client=yt_client, session_index=session_index)
yt_age_query = {'videoId': video_id}
yt_age_query.update(self._generate_player_context(sts))
pr = self._extract_response(
item_id=video_id, ep='player', query=yt_age_query,
ytcfg=ytcfg_age, headers=ytage_headers, fatal=False,
default_client=yt_client,
note='Downloading %sage-gated player API JSON' % ('android ' if force_mobile_client else '')
) or {}
def _get_requested_clients(self, url, smuggled_data):
requested_clients = [client for client in self._configuration_arg('player_client')
if client[:0] != '_' and client in self._YT_CLIENTS]
if not requested_clients:
requested_clients = ['android', 'web']
if pr:
player_response = pr
if smuggled_data.get('is_music_url') or self.is_music_url(url):
requested_clients.extend(
f'{client}_music' for client in requested_clients if not client.endswith('_music'))
trailer_video_id = try_get(
playability_status,
lambda x: x['errorScreen']['playerLegacyDesktopYpcTrailerRenderer']['trailerVideoId'],
compat_str)
if trailer_video_id:
return self.url_result(
trailer_video_id, self.ie_key(), trailer_video_id)
return orderedSet(requested_clients)
search_meta = (
lambda x: self._html_search_meta(x, webpage, default=None)) \
if webpage else lambda x: None
def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, player_url, identity_token):
initial_pr = None
if webpage:
initial_pr = self._extract_yt_initial_variable(
webpage, self._YT_INITIAL_PLAYER_RESPONSE_RE,
video_id, 'initial player response')
video_details = player_response.get('videoDetails') or {}
microformat = try_get(
player_response,
lambda x: x['microformat']['playerMicroformatRenderer'],
dict) or {}
video_title = video_details.get('title') \
or self._get_text(microformat.get('title')) \
or search_meta(['og:title', 'twitter:title', 'title'])
video_description = video_details.get('shortDescription')
if not smuggled_data.get('force_singlefeed', False):
if not self.get_param('noplaylist'):
multifeed_metadata_list = try_get(
player_response,
lambda x: x['multicamera']['playerLegacyMulticameraRenderer']['metadataList'],
compat_str)
if multifeed_metadata_list:
entries = []
feed_ids = []
for feed in multifeed_metadata_list.split(','):
# Unquote should take place before split on comma (,) since textual
# fields may contain comma as well (see
# https://github.com/ytdl-org/youtube-dl/issues/8536)
feed_data = compat_parse_qs(
compat_urllib_parse_unquote_plus(feed))
def feed_entry(name):
return try_get(
feed_data, lambda x: x[name][0], compat_str)
feed_id = feed_entry('id')
if not feed_id:
continue
feed_title = feed_entry('title')
title = video_title
if feed_title:
title += ' (%s)' % feed_title
entries.append({
'_type': 'url_transparent',
'ie_key': 'Youtube',
'url': smuggle_url(
base_url + 'watch?v=' + feed_data['id'][0],
{'force_singlefeed': True}),
'title': title,
})
feed_ids.append(feed_id)
self.to_screen(
'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
% (', '.join(feed_ids), video_id))
return self.playlist_result(
entries, video_id, video_title, video_description)
age_gated = False
for client in clients:
player_ytcfg = master_ytcfg if client == 'web' else {}
if age_gated:
pr = None
elif client == 'web' and initial_pr:
pr = initial_pr
else:
self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
if client == 'web_music' and 'configs' not in self._configuration_arg('player_skip'):
ytm_webpage = self._download_webpage(
'https://music.youtube.com',
video_id, fatal=False, note='Downloading remix client config')
player_ytcfg = self.extract_ytcfg(video_id, ytm_webpage) or {}
pr = self._extract_player_response(
client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, identity_token, player_url, initial_pr)
if pr:
yield pr
if age_gated or traverse_obj(pr, ('playabilityStatus', 'reason')) in self._AGE_GATE_REASONS:
age_gated = True
pr = self._extract_age_gated_player_response(
client, video_id, player_ytcfg or master_ytcfg, identity_token, player_url, initial_pr)
if pr:
yield pr
# Android player_response does not have microFormats which are needed for
# extraction of some data. So we return the initial_pr with formats
# stripped out even if not requested by the user
# See: https://github.com/yt-dlp/yt-dlp/issues/501
if initial_pr and 'web' not in clients:
initial_pr['streamingData'] = None
yield initial_pr
formats, itags, stream_ids = [], [], []
def _extract_formats(self, streaming_data, video_id, player_url, is_live):
itags, stream_ids = [], []
itag_qualities = {}
q = qualities([
# "tiny" is the smallest video-only format. But some audio-only formats
@ -2503,12 +2472,7 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'tiny', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
])
streaming_data = player_response.get('streamingData') or {}
streaming_formats = streaming_data.get('formats') or []
streaming_formats.extend(streaming_data.get('adaptiveFormats') or [])
streaming_formats.extend(ytm_streaming_data.get('formats') or [])
streaming_formats.extend(ytm_streaming_data.get('adaptiveFormats') or [])
streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...), default=[])
for fmt in streaming_formats:
if fmt.get('targetDurationSec') or fmt.get('drmFamilies'):
@ -2554,7 +2518,8 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'asr': int_or_none(fmt.get('audioSampleRate')),
'filesize': int_or_none(fmt.get('contentLength')),
'format_id': itag,
'format_note': audio_track.get('displayName') or fmt.get('qualityLabel') or quality,
'format_note': ', '.join(filter(None, (
audio_track.get('displayName'), fmt.get('qualityLabel') or quality))),
'fps': int_or_none(fmt.get('fps')),
'height': int_or_none(fmt.get('height')),
'quality': q(quality),
@ -2572,6 +2537,7 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
# but is actually worse than all other formats
if dct['ext'] == '3gp':
dct['quality'] = q('tiny')
dct['preference'] = -10
no_audio = dct.get('acodec') == 'none'
no_video = dct.get('vcodec') == 'none'
if no_audio:
@ -2585,22 +2551,25 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
}
if dct.get('ext'):
dct['container'] = dct['ext'] + '_dash'
formats.append(dct)
yield dct
skip_manifests = self._configuration_arg('skip')
get_dash = 'dash' not in skip_manifests and self.get_param('youtube_include_dash_manifest', True)
get_dash = not is_live and 'dash' not in skip_manifests and self.get_param('youtube_include_dash_manifest', True)
get_hls = 'hls' not in skip_manifests and self.get_param('youtube_include_hls_manifest', True)
for sd in (streaming_data, ytm_streaming_data):
for sd in streaming_data:
hls_manifest_url = get_hls and sd.get('hlsManifestUrl')
if hls_manifest_url:
for f in self._extract_m3u8_formats(
hls_manifest_url, video_id, 'mp4', fatal=False):
itag = self._search_regex(
r'/itag/(\d+)', f['url'], 'itag', default=None)
if itag in itags:
continue
if itag:
f['format_id'] = itag
formats.append(f)
itags.append(itag)
yield f
dash_manifest_url = get_dash and sd.get('dashManifestUrl')
if dash_manifest_url:
@ -2609,6 +2578,8 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
itag = f['format_id']
if itag in itags:
continue
if itag:
itags.append(itag)
if itag in itag_qualities:
f['quality'] = q(itag_qualities[itag])
filesize = int_or_none(self._search_regex(
@ -2616,33 +2587,142 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
or f['url'], 'file size', default=None))
if filesize:
f['filesize'] = filesize
formats.append(f)
yield f
def _real_extract(self, url):
url, smuggled_data = unsmuggle_url(url, {})
video_id = self._match_id(url)
base_url = self.http_scheme() + '//www.youtube.com/'
webpage_url = base_url + 'watch?v=' + video_id
webpage = self._download_webpage(
webpage_url + '&bpctr=9999999999&has_verified=1', video_id, fatal=False)
master_ytcfg = self.extract_ytcfg(video_id, webpage) or self._get_default_ytcfg()
player_url = self._extract_player_url(master_ytcfg, webpage)
identity_token = self._extract_identity_token(webpage, video_id)
player_responses = list(self._extract_player_responses(
self._get_requested_clients(url, smuggled_data),
video_id, webpage, master_ytcfg, player_url, identity_token))
get_first = lambda obj, keys, **kwargs: (
traverse_obj(obj, (..., *variadic(keys)), **kwargs) or [None])[0]
playability_statuses = traverse_obj(
player_responses, (..., 'playabilityStatus'), expected_type=dict, default=[])
trailer_video_id = get_first(
playability_statuses,
('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
expected_type=str)
if trailer_video_id:
return self.url_result(
trailer_video_id, self.ie_key(), trailer_video_id)
search_meta = ((lambda x: self._html_search_meta(x, webpage, default=None))
if webpage else (lambda x: None))
video_details = traverse_obj(
player_responses, (..., 'videoDetails'), expected_type=dict, default=[])
microformats = traverse_obj(
player_responses, (..., 'microformat', 'playerMicroformatRenderer'),
expected_type=dict, default=[])
video_title = (
get_first(video_details, 'title')
or self._get_text(microformats, (..., 'title'))
or search_meta(['og:title', 'twitter:title', 'title']))
video_description = get_first(video_details, 'shortDescription')
if not smuggled_data.get('force_singlefeed', False):
if not self.get_param('noplaylist'):
multifeed_metadata_list = get_first(
player_responses,
('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
expected_type=str)
if multifeed_metadata_list:
entries = []
feed_ids = []
for feed in multifeed_metadata_list.split(','):
# Unquote should take place before split on comma (,) since textual
# fields may contain comma as well (see
# https://github.com/ytdl-org/youtube-dl/issues/8536)
feed_data = compat_parse_qs(
compat_urllib_parse_unquote_plus(feed))
def feed_entry(name):
return try_get(
feed_data, lambda x: x[name][0], compat_str)
feed_id = feed_entry('id')
if not feed_id:
continue
feed_title = feed_entry('title')
title = video_title
if feed_title:
title += ' (%s)' % feed_title
entries.append({
'_type': 'url_transparent',
'ie_key': 'Youtube',
'url': smuggle_url(
'%swatch?v=%s' % (base_url, feed_data['id'][0]),
{'force_singlefeed': True}),
'title': title,
})
feed_ids.append(feed_id)
self.to_screen(
'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
% (', '.join(feed_ids), video_id))
return self.playlist_result(
entries, video_id, video_title, video_description)
else:
self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
category = get_first(microformats, 'category') or search_meta('genre')
channel_id = get_first(video_details, 'channelId') \
or get_first(microformats, 'externalChannelId') \
or search_meta('channelId')
duration = int_or_none(
get_first(video_details, 'lengthSeconds')
or get_first(microformats, 'lengthSeconds')) \
or parse_duration(search_meta('duration'))
is_live = get_first(video_details, 'isLive')
is_upcoming = get_first(video_details, 'isUpcoming')
owner_profile_url = get_first(microformats, 'ownerProfileUrl')
streaming_data = traverse_obj(player_responses, (..., 'streamingData'), default=[])
formats = list(self._extract_formats(streaming_data, video_id, player_url, is_live))
if not formats:
if not self.get_param('allow_unplayable_formats') and streaming_data.get('licenseInfos'):
if not self.get_param('allow_unplayable_formats') and traverse_obj(streaming_data, (..., 'licenseInfos')):
self.raise_no_formats(
'This video is DRM protected.', expected=True)
pemr = try_get(
playability_status,
lambda x: x['errorScreen']['playerErrorMessageRenderer'],
dict) or {}
reason = self._get_text(pemr.get('reason')) or playability_status.get('reason')
subreason = pemr.get('subreason')
pemr = get_first(
playability_statuses,
('errorScreen', 'playerErrorMessageRenderer'), expected_type=dict) or {}
reason = self._get_text(pemr, 'reason') or get_first(playability_statuses, 'reason')
subreason = clean_html(self._get_text(pemr, 'subreason') or '')
if subreason:
subreason = clean_html(self._get_text(subreason))
if subreason == 'The uploader has not made this video available in your country.':
countries = microformat.get('availableCountries')
countries = get_first(microformats, 'availableCountries')
if not countries:
regions_allowed = search_meta('regionsAllowed')
countries = regions_allowed.split(',') if regions_allowed else None
self.raise_geo_restricted(subreason, countries, metadata_available=True)
reason += '\n' + subreason
reason += f'. {subreason}'
if reason:
self.raise_no_formats(reason, expected=True)
for f in formats:
# TODO: detect if throttled
if '&n=' in f['url']: # possibly throttled
f['source_preference'] = -10
# note = f.get('format_note')
# f['format_note'] = f'{note} (throttled)' if note else '(throttled)'
self._sort_formats(formats)
keywords = video_details.get('keywords') or []
keywords = get_first(video_details, 'keywords', expected_type=list) or []
if not keywords and webpage:
keywords = [
unescapeHTML(m.group('content'))
@ -2660,23 +2740,11 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
f['stretched_ratio'] = ratio
break
category = microformat.get('category') or search_meta('genre')
channel_id = video_details.get('channelId') \
or microformat.get('externalChannelId') \
or search_meta('channelId')
duration = int_or_none(
video_details.get('lengthSeconds')
or microformat.get('lengthSeconds')) \
or parse_duration(search_meta('duration'))
is_live = video_details.get('isLive')
is_upcoming = video_details.get('isUpcoming')
owner_profile_url = microformat.get('ownerProfileUrl')
thumbnails = []
for container in (video_details, microformat):
for thumbnail in (try_get(
container,
lambda x: x['thumbnail']['thumbnails'], list) or []):
thumbnail_dicts = traverse_obj(
(video_details, microformats), (..., ..., 'thumbnail', 'thumbnails', ...),
expected_type=dict, default=[])
for thumbnail in thumbnail_dicts:
thumbnail_url = thumbnail.get('url')
if not thumbnail_url:
continue
@ -2725,34 +2793,31 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
'thumbnails': thumbnails,
'description': video_description,
'upload_date': unified_strdate(
microformat.get('uploadDate')
get_first(microformats, 'uploadDate')
or search_meta('uploadDate')),
'uploader': video_details['author'],
'uploader': get_first(video_details, 'author'),
'uploader_id': self._search_regex(r'/(?:channel|user)/([^/?&#]+)', owner_profile_url, 'uploader id') if owner_profile_url else None,
'uploader_url': owner_profile_url,
'channel_id': channel_id,
'channel_url': 'https://www.youtube.com/channel/' + channel_id if channel_id else None,
'channel_url': f'https://www.youtube.com/channel/{channel_id}' if channel_id else None,
'duration': duration,
'view_count': int_or_none(
video_details.get('viewCount')
or microformat.get('viewCount')
get_first((video_details, microformats), (..., 'viewCount'))
or search_meta('interactionCount')),
'average_rating': float_or_none(video_details.get('averageRating')),
'average_rating': float_or_none(get_first(video_details, 'averageRating')),
'age_limit': 18 if (
microformat.get('isFamilySafe') is False
get_first(microformats, 'isFamilySafe') is False
or search_meta('isFamilyFriendly') == 'false'
or search_meta('og:restrictions:age') == '18+') else 0,
'webpage_url': webpage_url,
'categories': [category] if category else None,
'tags': keywords,
'is_live': is_live,
'playable_in_embed': playability_status.get('playableInEmbed'),
'was_live': video_details.get('isLiveContent'),
'playable_in_embed': get_first(playability_statuses, 'playableInEmbed'),
'was_live': get_first(video_details, 'isLiveContent'),
}
pctr = try_get(
player_response,
lambda x: x['captions']['playerCaptionsTracklistRenderer'], dict)
pctr = get_first(player_responses, ('captions', 'playerCaptionsTracklistRenderer'), expected_type=dict)
subtitles = {}
if pctr:
def process_language(container, base_url, lang_code, sub_name, query):
@ -2827,9 +2892,13 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
webpage, self._YT_INITIAL_DATA_RE, video_id,
'yt initial data')
if not initial_data:
headers = self.generate_api_headers(
master_ytcfg, identity_token, self._extract_account_syncid(master_ytcfg),
session_index=self._extract_session_index(master_ytcfg))
initial_data = self._extract_response(
item_id=video_id, ep='next', fatal=False,
ytcfg=ytcfg, headers=headers, query={'videoId': video_id},
ytcfg=master_ytcfg, headers=headers, query={'videoId': video_id},
note='Downloading initial data API JSON')
try:
@ -2943,8 +3012,8 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
if v:
info[d_k] = v
is_private = bool_or_none(video_details.get('isPrivate'))
is_unlisted = bool_or_none(microformat.get('isUnlisted'))
is_private = get_first(video_details, 'isPrivate', expected_type=bool)
is_unlisted = get_first(microformats, 'isUnlisted', expected_type=bool)
is_membersonly = None
is_premium = None
if initial_data and is_private is not None:
@ -2976,9 +3045,8 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
get_comments = self.get_param('getcomments', False)
if get_annotations or get_comments:
xsrf_token = None
ytcfg = self._extract_ytcfg(video_id, webpage)
if ytcfg:
xsrf_token = try_get(ytcfg, lambda x: x['XSRF_TOKEN'], compat_str)
if master_ytcfg:
xsrf_token = try_get(master_ytcfg, lambda x: x['XSRF_TOKEN'], compat_str)
if not xsrf_token:
xsrf_token = self._search_regex(
r'([\'"])XSRF_TOKEN\1\s*:\s*([\'"])(?P<xsrf_token>(?:(?!\2).)+)\2',
@ -2986,12 +3054,14 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
# annotations
if get_annotations:
invideo_url = try_get(
player_response, lambda x: x['annotations'][0]['playerAnnotationsUrlsRenderer']['invideoUrl'], compat_str)
invideo_url = get_first(
player_responses,
('annotations', 0, 'playerAnnotationsUrlsRenderer', 'invideoUrl'),
expected_type=str)
if xsrf_token and invideo_url:
xsrf_field_name = None
if ytcfg:
xsrf_field_name = try_get(ytcfg, lambda x: x['XSRF_FIELD_NAME'], compat_str)
if master_ytcfg:
xsrf_field_name = try_get(master_ytcfg, lambda x: x['XSRF_FIELD_NAME'], compat_str)
if not xsrf_field_name:
xsrf_field_name = self._search_regex(
r'([\'"])XSRF_FIELD_NAME\1\s*:\s*([\'"])(?P<xsrf_field_name>\w+)\2',
@ -3004,9 +3074,9 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
data=urlencode_postdata({xsrf_field_name: xsrf_token}))
if get_comments:
info['__post_extractor'] = lambda: self._extract_comments(ytcfg, video_id, contents, webpage)
info['__post_extractor'] = lambda: self._extract_comments(master_ytcfg, video_id, contents, webpage)
self.mark_watched(video_id, player_response)
self.mark_watched(video_id, player_responses)
return info
@ -3287,7 +3357,7 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
}, {
'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
'info_dict': {
'id': 'X1whbWASnNQ', # This will keep changing
'id': 'FMtPN8yp5LU', # This will keep changing
'ext': 'mp4',
'title': compat_str,
'uploader': 'Sky News',
@ -3693,7 +3763,7 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
for page_num in itertools.count(1):
if not continuation:
break
headers = self._generate_api_headers(ytcfg, identity_token, account_syncid, visitor_data)
headers = self.generate_api_headers(ytcfg, identity_token, account_syncid, visitor_data)
response = self._extract_response(
item_id='%s page %s' % (item_id, page_num),
query=continuation, headers=headers, ytcfg=ytcfg,
@ -3843,7 +3913,7 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
'channel': metadata['uploader'],
'channel_id': metadata['uploader_id'],
'channel_url': metadata['uploader_url']})
ytcfg = self._extract_ytcfg(item_id, webpage)
ytcfg = self.extract_ytcfg(item_id, webpage)
return self.playlist_result(
self._entries(
selected_tab, playlist_id,
@ -3853,8 +3923,8 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
def _extract_mix_playlist(self, playlist, playlist_id, data, webpage):
first_id = last_id = None
ytcfg = self._extract_ytcfg(playlist_id, webpage)
headers = self._generate_api_headers(
ytcfg = self.extract_ytcfg(playlist_id, webpage)
headers = self.generate_api_headers(
ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
identity_token=self._extract_identity_token(webpage, item_id=playlist_id))
for page_num in itertools.count(1):
@ -3971,8 +4041,8 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
params = browse_endpoint.get('params')
break
ytcfg = self._extract_ytcfg(item_id, webpage)
headers = self._generate_api_headers(
ytcfg = self.extract_ytcfg(item_id, webpage)
headers = self.generate_api_headers(
ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
identity_token=self._extract_identity_token(webpage, item_id=item_id),
visitor_data=try_get(
@ -3999,7 +4069,7 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
webpage = self._download_webpage(
url, item_id,
'Downloading webpage%s' % (' (retry #%d)' % count if count else ''))
data = self._extract_yt_initial_data(item_id, webpage)
data = self.extract_yt_initial_data(item_id, webpage)
if data.get('contents') or data.get('currentVideoEndpoint'):
break
# Extract alerts here only when there is error
@ -4165,6 +4235,7 @@ class YoutubePlaylistIE(InfoExtractor):
'id': 'PLBB231211A4F62143',
'uploader': 'Wickydoo',
'uploader_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
},
'playlist_mincount': 29,
}, {
@ -4187,12 +4258,13 @@ class YoutubePlaylistIE(InfoExtractor):
}
}, {
'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
'playlist_mincount': 982,
'playlist_mincount': 654,
'info_dict': {
'title': '2018 Chinese New Singles (11/6 updated)',
'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
'uploader': 'LBK',
'uploader_id': 'UC21nz3_MesPLqtDqwdvnoxA',
'description': 'md5:da521864744d60a198e3a88af4db0d9d',
}
}, {
'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
@ -4366,7 +4438,7 @@ class YoutubeSearchIE(SearchInfoExtractor, YoutubeTabIE):
def _get_n_results(self, query, n):
"""Get a specified number of results for a query"""
return self.playlist_result(self._entries(query, n), query)
return self.playlist_result(self._entries(query, n), query, query)
class YoutubeSearchDateIE(YoutubeSearchIE):
@ -4385,6 +4457,7 @@ class YoutubeSearchURLIE(YoutubeSearchIE):
'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
'playlist_mincount': 5,
'info_dict': {
'id': 'youtube-dl test video',
'title': 'youtube-dl test video',
}
}, {