]> Raphaël G. Git Repositories - youtubedl/blob - youtube_dl/extractor/youtube.py
Rapsys Git / youtubedl / blob
? search:


0cb837afcc7d448ec6ae5a8b3496642cc7f956c0
[youtubedl] / youtube_dl / extractor / youtube.py
1 # coding: utf-8
2
3 from __future__ import unicode_literals
4
5
6 import itertools
7 import json
8 import os.path
9 import re
10 import traceback
11
12 from .common import InfoExtractor, SearchInfoExtractor
13 from .subtitles import SubtitlesInfoExtractor
14 from ..jsinterp import JSInterpreter
15 from ..swfinterp import SWFInterpreter
16 from ..utils import (
17 compat_chr,
18 compat_parse_qs,
19 compat_urllib_parse,
20 compat_urllib_request,
21 compat_urlparse,
22 compat_str,
23
24 clean_html,
25 get_element_by_id,
26 get_element_by_attribute,
27 ExtractorError,
28 int_or_none,
29 OnDemandPagedList,
30 unescapeHTML,
31 unified_strdate,
32 orderedSet,
33 uppercase_escape,
34 )
35
36 class YoutubeBaseInfoExtractor(InfoExtractor):
37 """Provide base functions for Youtube extractors"""
38 _LOGIN_URL = 'https://accounts.google.com/ServiceLogin'
39 _TWOFACTOR_URL = 'https://accounts.google.com/SecondFactor'
40 _LANG_URL = r'https://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
41 _AGE_URL = 'https://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
42 _NETRC_MACHINE = 'youtube'
43 # If True it will raise an error if no login info is provided
44 _LOGIN_REQUIRED = False
45
46 def _set_language(self):
47 return bool(self._download_webpage(
48 self._LANG_URL, None,
49 note='Setting language', errnote='unable to set language',
50 fatal=False))
51
52 def _login(self):
53 """
54 Attempt to log in to YouTube.
55 True is returned if successful or skipped.
56 False is returned if login failed.
57
58 If _LOGIN_REQUIRED is set and no authentication was provided, an error is raised.
59 """
60 (username, password) = self._get_login_info()
61 # No authentication to be performed
62 if username is None:
63 if self._LOGIN_REQUIRED:
64 raise ExtractorError('No login info available, needed for using %s.' % self.IE_NAME, expected=True)
65 return True
66
67 login_page = self._download_webpage(
68 self._LOGIN_URL, None,
69 note='Downloading login page',
70 errnote='unable to fetch login page', fatal=False)
71 if login_page is False:
72 return
73
74 galx = self._search_regex(r'(?s)<input.+?name="GALX".+?value="(.+?)"',
75 login_page, 'Login GALX parameter')
76
77 # Log in
78 login_form_strs = {
79 'continue': 'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
80 'Email': username,
81 'GALX': galx,
82 'Passwd': password,
83
84 'PersistentCookie': 'yes',
85 '_utf8': '霱',
86 'bgresponse': 'js_disabled',
87 'checkConnection': '',
88 'checkedDomains': 'youtube',
89 'dnConn': '',
90 'pstMsg': '0',
91 'rmShown': '1',
92 'secTok': '',
93 'signIn': 'Sign in',
94 'timeStmp': '',
95 'service': 'youtube',
96 'uilel': '3',
97 'hl': 'en_US',
98 }
99
100 # Convert to UTF-8 *before* urlencode because Python 2.x's urlencode
101 # chokes on unicode
102 login_form = dict((k.encode('utf-8'), v.encode('utf-8')) for k,v in login_form_strs.items())
103 login_data = compat_urllib_parse.urlencode(login_form).encode('ascii')
104
105 req = compat_urllib_request.Request(self._LOGIN_URL, login_data)
106 login_results = self._download_webpage(
107 req, None,
108 note='Logging in', errnote='unable to log in', fatal=False)
109 if login_results is False:
110 return False
111
112 if re.search(r'id="errormsg_0_Passwd"', login_results) is not None:
113 raise ExtractorError('Please use your account password and a two-factor code instead of an application-specific password.', expected=True)
114
115 # Two-Factor
116 # TODO add SMS and phone call support - these require making a request and then prompting the user
117
118 if re.search(r'(?i)<form[^>]* id="gaia_secondfactorform"', login_results) is not None:
119 tfa_code = self._get_tfa_info()
120
121 if tfa_code is None:
122 self._downloader.report_warning('Two-factor authentication required. Provide it with --twofactor <code>')
123 self._downloader.report_warning('(Note that only TOTP (Google Authenticator App) codes work at this time.)')
124 return False
125
126 # Unlike the first login form, secTok and timeStmp are both required for the TFA form
127
128 match = re.search(r'id="secTok"\n\s+value=\'(.+)\'/>', login_results, re.M | re.U)
129 if match is None:
130 self._downloader.report_warning('Failed to get secTok - did the page structure change?')
131 secTok = match.group(1)
132 match = re.search(r'id="timeStmp"\n\s+value=\'(.+)\'/>', login_results, re.M | re.U)
133 if match is None:
134 self._downloader.report_warning('Failed to get timeStmp - did the page structure change?')
135 timeStmp = match.group(1)
136
137 tfa_form_strs = {
138 'continue': 'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
139 'smsToken': '',
140 'smsUserPin': tfa_code,
141 'smsVerifyPin': 'Verify',
142
143 'PersistentCookie': 'yes',
144 'checkConnection': '',
145 'checkedDomains': 'youtube',
146 'pstMsg': '1',
147 'secTok': secTok,
148 'timeStmp': timeStmp,
149 'service': 'youtube',
150 'hl': 'en_US',
151 }
152 tfa_form = dict((k.encode('utf-8'), v.encode('utf-8')) for k,v in tfa_form_strs.items())
153 tfa_data = compat_urllib_parse.urlencode(tfa_form).encode('ascii')
154
155 tfa_req = compat_urllib_request.Request(self._TWOFACTOR_URL, tfa_data)
156 tfa_results = self._download_webpage(
157 tfa_req, None,
158 note='Submitting TFA code', errnote='unable to submit tfa', fatal=False)
159
160 if tfa_results is False:
161 return False
162
163 if re.search(r'(?i)<form[^>]* id="gaia_secondfactorform"', tfa_results) is not None:
164 self._downloader.report_warning('Two-factor code expired. Please try again, or use a one-use backup code instead.')
165 return False
166 if re.search(r'(?i)<form[^>]* id="gaia_loginform"', tfa_results) is not None:
167 self._downloader.report_warning('unable to log in - did the page structure change?')
168 return False
169 if re.search(r'smsauth-interstitial-reviewsettings', tfa_results) is not None:
170 self._downloader.report_warning('Your Google account has a security notice. Please log in on your web browser, resolve the notice, and try again.')
171 return False
172
173 if re.search(r'(?i)<form[^>]* id="gaia_loginform"', login_results) is not None:
174 self._downloader.report_warning('unable to log in: bad username or password')
175 return False
176 return True
177
178 def _confirm_age(self):
179 age_form = {
180 'next_url': '/',
181 'action_confirm': 'Confirm',
182 }
183 req = compat_urllib_request.Request(self._AGE_URL,
184 compat_urllib_parse.urlencode(age_form).encode('ascii'))
185
186 self._download_webpage(
187 req, None,
188 note='Confirming age', errnote='Unable to confirm age',
189 fatal=False)
190
191 def _real_initialize(self):
192 if self._downloader is None:
193 return
194 if self._get_login_info()[0] is not None:
195 if not self._set_language():
196 return
197 if not self._login():
198 return
199 self._confirm_age()
200
201
202 class YoutubeIE(YoutubeBaseInfoExtractor, SubtitlesInfoExtractor):
203 IE_DESC = 'YouTube.com'
204 _VALID_URL = r"""(?x)^
205 (
206 (?:https?://|//) # http(s):// or protocol-independent URL
207 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/|
208 (?:www\.)?deturl\.com/www\.youtube\.com/|
209 (?:www\.)?pwnyoutube\.com/|
210 (?:www\.)?yourepeat\.com/|
211 tube\.majestyc\.net/|
212 youtube\.googleapis\.com/) # the various hostnames, with wildcard subdomains
213 (?:.*?\#/)? # handle anchor (#/) redirect urls
214 (?: # the various things that can precede the ID:
215 (?:(?:v|embed|e)/(?!videoseries)) # v/ or embed/ or e/
216 |(?: # or the v= param in all its forms
217 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
218 (?:\?|\#!?) # the params delimiter ? or # or #!
219 (?:.*?&)? # any other preceding param (like /?s=tuff&v=xxxx)
220 v=
221 )
222 ))
223 |youtu\.be/ # just youtu.be/xxxx
224 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
225 )
226 )? # all until now is optional -> you can pass the naked ID
227 ([0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
228 (?!.*?&list=) # combined list/video URLs are handled by the playlist IE
229 (?(1).+)? # if we found the ID, everything can follow
230 $"""
231 _NEXT_URL_RE = r'[\?&]next_url=([^&]+)'
232 _formats = {
233 '5': {'ext': 'flv', 'width': 400, 'height': 240},
234 '6': {'ext': 'flv', 'width': 450, 'height': 270},
235 '13': {'ext': '3gp'},
236 '17': {'ext': '3gp', 'width': 176, 'height': 144},
237 '18': {'ext': 'mp4', 'width': 640, 'height': 360},
238 '22': {'ext': 'mp4', 'width': 1280, 'height': 720},
239 '34': {'ext': 'flv', 'width': 640, 'height': 360},
240 '35': {'ext': 'flv', 'width': 854, 'height': 480},
241 '36': {'ext': '3gp', 'width': 320, 'height': 240},
242 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080},
243 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072},
244 '43': {'ext': 'webm', 'width': 640, 'height': 360},
245 '44': {'ext': 'webm', 'width': 854, 'height': 480},
246 '45': {'ext': 'webm', 'width': 1280, 'height': 720},
247 '46': {'ext': 'webm', 'width': 1920, 'height': 1080},
248
249
250 # 3d videos
251 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'preference': -20},
252 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'preference': -20},
253 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'preference': -20},
254 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'preference': -20},
255 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'preference': -20},
256 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'preference': -20},
257 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'preference': -20},
258
259 # Apple HTTP Live Streaming
260 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'preference': -10},
261 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'preference': -10},
262 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'preference': -10},
263 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'preference': -10},
264 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'preference': -10},
265 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'preference': -10},
266 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'preference': -10},
267
268 # DASH mp4 video
269 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
270 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
271 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
272 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
273 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
274 '138': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
275 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
276 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
277 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'h264'},
278 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'h264'},
279 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'vcodec': 'h264'},
280
281 # Dash mp4 audio
282 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 48, 'preference': -50},
283 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 128, 'preference': -50},
284 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 256, 'preference': -50},
285
286 # Dash webm
287 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
288 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
289 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
290 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
291 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
292 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
293 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'container': 'webm', 'vcodec': 'VP9'},
294 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
295 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
296 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
297 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
298 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
299 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
300 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
301 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
302 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
303 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'VP9'},
304 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'VP9'},
305
306 # Dash webm audio
307 '171': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'abr': 128, 'preference': -50},
308 '172': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'abr': 256, 'preference': -50},
309
310 # Dash webm audio with opus inside
311 '249': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50, 'preference': -50},
312 '250': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70, 'preference': -50},
313 '251': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160, 'preference': -50},
314
315 # RTMP (unnamed)
316 '_rtmp': {'protocol': 'rtmp'},
317 }
318
319 IE_NAME = 'youtube'
320 _TESTS = [
321 {
322 'url': 'http://www.youtube.com/watch?v=BaW_jenozKc',
323 'info_dict': {
324 'id': 'BaW_jenozKc',
325 'ext': 'mp4',
326 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
327 'uploader': 'Philipp Hagemeister',
328 'uploader_id': 'phihag',
329 'upload_date': '20121002',
330 'description': 'test chars: "\'/\\ä↭𝕐\ntest URL: https://github.com/rg3/youtube-dl/issues/1892\n\nThis is a test video for youtube-dl.\n\nFor more information, contact phihag@phihag.de .',
331 'categories': ['Science & Technology'],
332 'like_count': int,
333 'dislike_count': int,
334 }
335 },
336 {
337 'url': 'http://www.youtube.com/watch?v=UxxajLWwzqY',
338 'note': 'Test generic use_cipher_signature video (#897)',
339 'info_dict': {
340 'id': 'UxxajLWwzqY',
341 'ext': 'mp4',
342 'upload_date': '20120506',
343 'title': 'Icona Pop - I Love It (feat. Charli XCX) [OFFICIAL VIDEO]',
344 'description': 'md5:fea86fda2d5a5784273df5c7cc994d9f',
345 'uploader': 'Icona Pop',
346 'uploader_id': 'IconaPop',
347 }
348 },
349 {
350 'url': 'https://www.youtube.com/watch?v=07FYdnEawAQ',
351 'note': 'Test VEVO video with age protection (#956)',
352 'info_dict': {
353 'id': '07FYdnEawAQ',
354 'ext': 'mp4',
355 'upload_date': '20130703',
356 'title': 'Justin Timberlake - Tunnel Vision (Explicit)',
357 'description': 'md5:64249768eec3bc4276236606ea996373',
358 'uploader': 'justintimberlakeVEVO',
359 'uploader_id': 'justintimberlakeVEVO',
360 }
361 },
362 {
363 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
364 'note': 'Embed-only video (#1746)',
365 'info_dict': {
366 'id': 'yZIXLfi8CZQ',
367 'ext': 'mp4',
368 'upload_date': '20120608',
369 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
370 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
371 'uploader': 'SET India',
372 'uploader_id': 'setindia'
373 }
374 },
375 {
376 'url': 'http://www.youtube.com/watch?v=a9LDPn-MO4I',
377 'note': '256k DASH audio (format 141) via DASH manifest',
378 'info_dict': {
379 'id': 'a9LDPn-MO4I',
380 'ext': 'm4a',
381 'upload_date': '20121002',
382 'uploader_id': '8KVIDEO',
383 'description': '',
384 'uploader': '8KVIDEO',
385 'title': 'UHDTV TEST 8K VIDEO.mp4'
386 },
387 'params': {
388 'youtube_include_dash_manifest': True,
389 'format': '141',
390 },
391 },
392 # DASH manifest with encrypted signature
393 {
394 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
395 'info_dict': {
396 'id': 'IB3lcPjvWLA',
397 'ext': 'm4a',
398 'title': 'Afrojack - The Spark ft. Spree Wilson',
399 'description': 'md5:9717375db5a9a3992be4668bbf3bc0a8',
400 'uploader': 'AfrojackVEVO',
401 'uploader_id': 'AfrojackVEVO',
402 'upload_date': '20131011',
403 },
404 'params': {
405 'youtube_include_dash_manifest': True,
406 'format': '141',
407 },
408 },
409 # Controversy video
410 {
411 'url': 'https://www.youtube.com/watch?v=T4XJQO3qol8',
412 'info_dict': {
413 'id': 'T4XJQO3qol8',
414 'ext': 'mp4',
415 'upload_date': '20100909',
416 'uploader': 'The Amazing Atheist',
417 'uploader_id': 'TheAmazingAtheist',
418 'title': 'Burning Everyone\'s Koran',
419 'description': 'SUBSCRIBE: http://www.youtube.com/saturninefilms\n\nEven Obama has taken a stand against freedom on this issue: http://www.huffingtonpost.com/2010/09/09/obama-gma-interview-quran_n_710282.html',
420 }
421 }
422 ]
423
424 def __init__(self, *args, **kwargs):
425 super(YoutubeIE, self).__init__(*args, **kwargs)
426 self._player_cache = {}
427
428 def report_video_info_webpage_download(self, video_id):
429 """Report attempt to download video info webpage."""
430 self.to_screen('%s: Downloading video info webpage' % video_id)
431
432 def report_information_extraction(self, video_id):
433 """Report attempt to extract video information."""
434 self.to_screen('%s: Extracting video information' % video_id)
435
436 def report_unavailable_format(self, video_id, format):
437 """Report extracted video URL."""
438 self.to_screen('%s: Format %s not available' % (video_id, format))
439
440 def report_rtmp_download(self):
441 """Indicate the download will use the RTMP protocol."""
442 self.to_screen('RTMP download detected')
443
444 def _signature_cache_id(self, example_sig):
445 """ Return a string representation of a signature """
446 return '.'.join(compat_str(len(part)) for part in example_sig.split('.'))
447
448 def _extract_signature_function(self, video_id, player_url, example_sig):
449 id_m = re.match(
450 r'.*-(?P<id>[a-zA-Z0-9_-]+)(?:/watch_as3|/html5player)?\.(?P<ext>[a-z]+)$',
451 player_url)
452 if not id_m:
453 raise ExtractorError('Cannot identify player %r' % player_url)
454 player_type = id_m.group('ext')
455 player_id = id_m.group('id')
456
457 # Read from filesystem cache
458 func_id = '%s_%s_%s' % (
459 player_type, player_id, self._signature_cache_id(example_sig))
460 assert os.path.basename(func_id) == func_id
461
462 cache_spec = self._downloader.cache.load('youtube-sigfuncs', func_id)
463 if cache_spec is not None:
464 return lambda s: ''.join(s[i] for i in cache_spec)
465
466 if player_type == 'js':
467 code = self._download_webpage(
468 player_url, video_id,
469 note='Downloading %s player %s' % (player_type, player_id),
470 errnote='Download of %s failed' % player_url)
471 res = self._parse_sig_js(code)
472 elif player_type == 'swf':
473 urlh = self._request_webpage(
474 player_url, video_id,
475 note='Downloading %s player %s' % (player_type, player_id),
476 errnote='Download of %s failed' % player_url)
477 code = urlh.read()
478 res = self._parse_sig_swf(code)
479 else:
480 assert False, 'Invalid player type %r' % player_type
481
482 if cache_spec is None:
483 test_string = ''.join(map(compat_chr, range(len(example_sig))))
484 cache_res = res(test_string)
485 cache_spec = [ord(c) for c in cache_res]
486
487 self._downloader.cache.store('youtube-sigfuncs', func_id, cache_spec)
488 return res
489
490 def _print_sig_code(self, func, example_sig):
491 def gen_sig_code(idxs):
492 def _genslice(start, end, step):
493 starts = '' if start == 0 else str(start)
494 ends = (':%d' % (end+step)) if end + step >= 0 else ':'
495 steps = '' if step == 1 else (':%d' % step)
496 return 's[%s%s%s]' % (starts, ends, steps)
497
498 step = None
499 start = '(Never used)' # Quelch pyflakes warnings - start will be
500 # set as soon as step is set
501 for i, prev in zip(idxs[1:], idxs[:-1]):
502 if step is not None:
503 if i - prev == step:
504 continue
505 yield _genslice(start, prev, step)
506 step = None
507 continue
508 if i - prev in [-1, 1]:
509 step = i - prev
510 start = prev
511 continue
512 else:
513 yield 's[%d]' % prev
514 if step is None:
515 yield 's[%d]' % i
516 else:
517 yield _genslice(start, i, step)
518
519 test_string = ''.join(map(compat_chr, range(len(example_sig))))
520 cache_res = func(test_string)
521 cache_spec = [ord(c) for c in cache_res]
522 expr_code = ' + '.join(gen_sig_code(cache_spec))
523 signature_id_tuple = '(%s)' % (
524 ', '.join(compat_str(len(p)) for p in example_sig.split('.')))
525 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
526 ' return %s\n') % (signature_id_tuple, expr_code)
527 self.to_screen('Extracted signature function:\n' + code)
528
529 def _parse_sig_js(self, jscode):
530 funcname = self._search_regex(
531 r'\.sig\|\|([a-zA-Z0-9]+)\(', jscode,
532 'Initial JS player signature function name')
533
534 jsi = JSInterpreter(jscode)
535 initial_function = jsi.extract_function(funcname)
536 return lambda s: initial_function([s])
537
538 def _parse_sig_swf(self, file_contents):
539 swfi = SWFInterpreter(file_contents)
540 TARGET_CLASSNAME = 'SignatureDecipher'
541 searched_class = swfi.extract_class(TARGET_CLASSNAME)
542 initial_function = swfi.extract_function(searched_class, 'decipher')
543 return lambda s: initial_function([s])
544
545 def _decrypt_signature(self, s, video_id, player_url, age_gate=False):
546 """Turn the encrypted s field into a working signature"""
547
548 if player_url is None:
549 raise ExtractorError('Cannot decrypt signature without player_url')
550
551 if player_url.startswith('//'):
552 player_url = 'https:' + player_url
553 try:
554 player_id = (player_url, self._signature_cache_id(s))
555 if player_id not in self._player_cache:
556 func = self._extract_signature_function(
557 video_id, player_url, s
558 )
559 self._player_cache[player_id] = func
560 func = self._player_cache[player_id]
561 if self._downloader.params.get('youtube_print_sig_code'):
562 self._print_sig_code(func, s)
563 return func(s)
564 except Exception as e:
565 tb = traceback.format_exc()
566 raise ExtractorError(
567 'Signature extraction failed: ' + tb, cause=e)
568
569 def _get_available_subtitles(self, video_id, webpage):
570 try:
571 sub_list = self._download_webpage(
572 'https://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id,
573 video_id, note=False)
574 except ExtractorError as err:
575 self._downloader.report_warning('unable to download video subtitles: %s' % compat_str(err))
576 return {}
577 lang_list = re.findall(r'name="([^"]*)"[^>]+lang_code="([\w\-]+)"', sub_list)
578
579 sub_lang_list = {}
580 for l in lang_list:
581 lang = l[1]
582 if lang in sub_lang_list:
583 continue
584 params = compat_urllib_parse.urlencode({
585 'lang': lang,
586 'v': video_id,
587 'fmt': self._downloader.params.get('subtitlesformat', 'srt'),
588 'name': unescapeHTML(l[0]).encode('utf-8'),
589 })
590 url = 'https://www.youtube.com/api/timedtext?' + params
591 sub_lang_list[lang] = url
592 if not sub_lang_list:
593 self._downloader.report_warning('video doesn\'t have subtitles')
594 return {}
595 return sub_lang_list
596
597 def _get_available_automatic_caption(self, video_id, webpage):
598 """We need the webpage for getting the captions url, pass it as an
599 argument to speed up the process."""
600 sub_format = self._downloader.params.get('subtitlesformat', 'srt')
601 self.to_screen('%s: Looking for automatic captions' % video_id)
602 mobj = re.search(r';ytplayer.config = ({.*?});', webpage)
603 err_msg = 'Couldn\'t find automatic captions for %s' % video_id
604 if mobj is None:
605 self._downloader.report_warning(err_msg)
606 return {}
607 player_config = json.loads(mobj.group(1))
608 try:
609 args = player_config[u'args']
610 caption_url = args[u'ttsurl']
611 timestamp = args[u'timestamp']
612 # We get the available subtitles
613 list_params = compat_urllib_parse.urlencode({
614 'type': 'list',
615 'tlangs': 1,
616 'asrs': 1,
617 })
618 list_url = caption_url + '&' + list_params
619 caption_list = self._download_xml(list_url, video_id)
620 original_lang_node = caption_list.find('track')
621 if original_lang_node is None or original_lang_node.attrib.get('kind') != 'asr' :
622 self._downloader.report_warning('Video doesn\'t have automatic captions')
623 return {}
624 original_lang = original_lang_node.attrib['lang_code']
625
626 sub_lang_list = {}
627 for lang_node in caption_list.findall('target'):
628 sub_lang = lang_node.attrib['lang_code']
629 params = compat_urllib_parse.urlencode({
630 'lang': original_lang,
631 'tlang': sub_lang,
632 'fmt': sub_format,
633 'ts': timestamp,
634 'kind': 'asr',
635 })
636 sub_lang_list[sub_lang] = caption_url + '&' + params
637 return sub_lang_list
638 # An extractor error can be raise by the download process if there are
639 # no automatic captions but there are subtitles
640 except (KeyError, ExtractorError):
641 self._downloader.report_warning(err_msg)
642 return {}
643
644 @classmethod
645 def extract_id(cls, url):
646 mobj = re.match(cls._VALID_URL, url, re.VERBOSE)
647 if mobj is None:
648 raise ExtractorError('Invalid URL: %s' % url)
649 video_id = mobj.group(2)
650 return video_id
651
652 def _extract_from_m3u8(self, manifest_url, video_id):
653 url_map = {}
654 def _get_urls(_manifest):
655 lines = _manifest.split('\n')
656 urls = filter(lambda l: l and not l.startswith('#'),
657 lines)
658 return urls
659 manifest = self._download_webpage(manifest_url, video_id, 'Downloading formats manifest')
660 formats_urls = _get_urls(manifest)
661 for format_url in formats_urls:
662 itag = self._search_regex(r'itag/(\d+?)/', format_url, 'itag')
663 url_map[itag] = format_url
664 return url_map
665
666 def _extract_annotations(self, video_id):
667 url = 'https://www.youtube.com/annotations_invideo?features=1&legacy=1&video_id=%s' % video_id
668 return self._download_webpage(url, video_id, note='Searching for annotations.', errnote='Unable to download video annotations.')
669
670 def _real_extract(self, url):
671 proto = (
672 'http' if self._downloader.params.get('prefer_insecure', False)
673 else 'https')
674
675 # Extract original video URL from URL with redirection, like age verification, using next_url parameter
676 mobj = re.search(self._NEXT_URL_RE, url)
677 if mobj:
678 url = proto + '://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
679 video_id = self.extract_id(url)
680
681 # Get video webpage
682 url = proto + '://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1&bpctr=9999999999' % video_id
683 pref_cookies = [
684 c for c in self._downloader.cookiejar
685 if c.domain == '.youtube.com' and c.name == 'PREF']
686 for pc in pref_cookies:
687 if 'hl=' in pc.value:
688 pc.value = re.sub(r'hl=[^&]+', 'hl=en', pc.value)
689 else:
690 if pc.value:
691 pc.value += '&'
692 pc.value += 'hl=en'
693 video_webpage = self._download_webpage(url, video_id)
694
695 # Attempt to extract SWF player URL
696 mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
697 if mobj is not None:
698 player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
699 else:
700 player_url = None
701
702 # Get video info
703 self.report_video_info_webpage_download(video_id)
704 if re.search(r'player-age-gate-content">', video_webpage) is not None:
705 age_gate = True
706 # We simulate the access to the video from www.youtube.com/v/{video_id}
707 # this can be viewed without login into Youtube
708 data = compat_urllib_parse.urlencode({
709 'video_id': video_id,
710 'eurl': 'https://youtube.googleapis.com/v/' + video_id,
711 'sts': self._search_regex(
712 r'"sts"\s*:\s*(\d+)', video_webpage, 'sts', default=''),
713 })
714 video_info_url = proto + '://www.youtube.com/get_video_info?' + data
715 video_info_webpage = self._download_webpage(
716 video_info_url, video_id,
717 note='Refetching age-gated info webpage',
718 errnote='unable to download video info webpage')
719 video_info = compat_parse_qs(video_info_webpage)
720 else:
721 age_gate = False
722 for el_type in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
723 video_info_url = (proto + '://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
724 % (video_id, el_type))
725 video_info_webpage = self._download_webpage(video_info_url, video_id,
726 note=False,
727 errnote='unable to download video info webpage')
728 video_info = compat_parse_qs(video_info_webpage)
729 if 'token' in video_info:
730 break
731 if 'token' not in video_info:
732 if 'reason' in video_info:
733 raise ExtractorError(
734 'YouTube said: %s' % video_info['reason'][0],
735 expected=True, video_id=video_id)
736 else:
737 raise ExtractorError(
738 '"token" parameter not in video info for unknown reason',
739 video_id=video_id)
740
741 if 'view_count' in video_info:
742 view_count = int(video_info['view_count'][0])
743 else:
744 view_count = None
745
746 # Check for "rental" videos
747 if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
748 raise ExtractorError('"rental" videos not supported')
749
750 # Start extracting information
751 self.report_information_extraction(video_id)
752
753 # uploader
754 if 'author' not in video_info:
755 raise ExtractorError('Unable to extract uploader name')
756 video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
757
758 # uploader_id
759 video_uploader_id = None
760 mobj = re.search(r'<link itemprop="url" href="http://www.youtube.com/(?:user|channel)/([^"]+)">', video_webpage)
761 if mobj is not None:
762 video_uploader_id = mobj.group(1)
763 else:
764 self._downloader.report_warning('unable to extract uploader nickname')
765
766 # title
767 if 'title' in video_info:
768 video_title = video_info['title'][0]
769 else:
770 self._downloader.report_warning('Unable to extract video title')
771 video_title = '_'
772
773 # thumbnail image
774 # We try first to get a high quality image:
775 m_thumb = re.search(r'<span itemprop="thumbnail".*?href="(.*?)">',
776 video_webpage, re.DOTALL)
777 if m_thumb is not None:
778 video_thumbnail = m_thumb.group(1)
779 elif 'thumbnail_url' not in video_info:
780 self._downloader.report_warning('unable to extract video thumbnail')
781 video_thumbnail = None
782 else: # don't panic if we can't find it
783 video_thumbnail = compat_urllib_parse.unquote_plus(video_info['thumbnail_url'][0])
784
785 # upload date
786 upload_date = None
787 mobj = re.search(r'(?s)id="eow-date.*?>(.*?)</span>', video_webpage)
788 if mobj is None:
789 mobj = re.search(
790 r'(?s)id="watch-uploader-info".*?>.*?(?:Published|Uploaded|Streamed live) on (.*?)</strong>',
791 video_webpage)
792 if mobj is not None:
793 upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
794 upload_date = unified_strdate(upload_date)
795
796 m_cat_container = self._search_regex(
797 r'(?s)<h4[^>]*>\s*Category\s*</h4>\s*<ul[^>]*>(.*?)</ul>',
798 video_webpage, 'categories', fatal=False)
799 if m_cat_container:
800 category = self._html_search_regex(
801 r'(?s)<a[^<]+>(.*?)</a>', m_cat_container, 'category',
802 default=None)
803 video_categories = None if category is None else [category]
804 else:
805 video_categories = None
806
807 # description
808 video_description = get_element_by_id("eow-description", video_webpage)
809 if video_description:
810 video_description = re.sub(r'''(?x)
811 <a\s+
812 (?:[a-zA-Z-]+="[^"]+"\s+)*?
813 title="([^"]+)"\s+
814 (?:[a-zA-Z-]+="[^"]+"\s+)*?
815 class="yt-uix-redirect-link"\s*>
816 [^<]+
817 </a>
818 ''', r'\1', video_description)
819 video_description = clean_html(video_description)
820 else:
821 fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
822 if fd_mobj:
823 video_description = unescapeHTML(fd_mobj.group(1))
824 else:
825 video_description = ''
826
827 def _extract_count(count_name):
828 count = self._search_regex(
829 r'id="watch-%s"[^>]*>.*?([\d,]+)\s*</span>' % re.escape(count_name),
830 video_webpage, count_name, default=None)
831 if count is not None:
832 return int(count.replace(',', ''))
833 return None
834 like_count = _extract_count('like')
835 dislike_count = _extract_count('dislike')
836
837 # subtitles
838 video_subtitles = self.extract_subtitles(video_id, video_webpage)
839
840 if self._downloader.params.get('listsubtitles', False):
841 self._list_available_subtitles(video_id, video_webpage)
842 return
843
844 if 'length_seconds' not in video_info:
845 self._downloader.report_warning('unable to extract video duration')
846 video_duration = None
847 else:
848 video_duration = int(compat_urllib_parse.unquote_plus(video_info['length_seconds'][0]))
849
850 # annotations
851 video_annotations = None
852 if self._downloader.params.get('writeannotations', False):
853 video_annotations = self._extract_annotations(video_id)
854
855 # Decide which formats to download
856 try:
857 mobj = re.search(r';ytplayer\.config\s*=\s*({.*?});', video_webpage)
858 if not mobj:
859 raise ValueError('Could not find vevo ID')
860 json_code = uppercase_escape(mobj.group(1))
861 ytplayer_config = json.loads(json_code)
862 args = ytplayer_config['args']
863 # Easy way to know if the 's' value is in url_encoded_fmt_stream_map
864 # this signatures are encrypted
865 if 'url_encoded_fmt_stream_map' not in args:
866 raise ValueError('No stream_map present') # caught below
867 re_signature = re.compile(r'[&,]s=')
868 m_s = re_signature.search(args['url_encoded_fmt_stream_map'])
869 if m_s is not None:
870 self.to_screen('%s: Encrypted signatures detected.' % video_id)
871 video_info['url_encoded_fmt_stream_map'] = [args['url_encoded_fmt_stream_map']]
872 m_s = re_signature.search(args.get('adaptive_fmts', ''))
873 if m_s is not None:
874 if 'adaptive_fmts' in video_info:
875 video_info['adaptive_fmts'][0] += ',' + args['adaptive_fmts']
876 else:
877 video_info['adaptive_fmts'] = [args['adaptive_fmts']]
878 except ValueError:
879 pass
880
881 def _map_to_format_list(urlmap):
882 formats = []
883 for itag, video_real_url in urlmap.items():
884 dct = {
885 'format_id': itag,
886 'url': video_real_url,
887 'player_url': player_url,
888 }
889 if itag in self._formats:
890 dct.update(self._formats[itag])
891 formats.append(dct)
892 return formats
893
894 if 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
895 self.report_rtmp_download()
896 formats = [{
897 'format_id': '_rtmp',
898 'protocol': 'rtmp',
899 'url': video_info['conn'][0],
900 'player_url': player_url,
901 }]
902 elif len(video_info.get('url_encoded_fmt_stream_map', [])) >= 1 or len(video_info.get('adaptive_fmts', [])) >= 1:
903 encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + ',' + video_info.get('adaptive_fmts',[''])[0]
904 if 'rtmpe%3Dyes' in encoded_url_map:
905 raise ExtractorError('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343 for more information.', expected=True)
906 url_map = {}
907 for url_data_str in encoded_url_map.split(','):
908 url_data = compat_parse_qs(url_data_str)
909 if 'itag' not in url_data or 'url' not in url_data:
910 continue
911 format_id = url_data['itag'][0]
912 url = url_data['url'][0]
913
914 if 'sig' in url_data:
915 url += '&signature=' + url_data['sig'][0]
916 elif 's' in url_data:
917 encrypted_sig = url_data['s'][0]
918
919 if not age_gate:
920 jsplayer_url_json = self._search_regex(
921 r'"assets":.+?"js":\s*("[^"]+")',
922 video_webpage, 'JS player URL')
923 player_url = json.loads(jsplayer_url_json)
924 if player_url is None:
925 player_url_json = self._search_regex(
926 r'ytplayer\.config.*?"url"\s*:\s*("[^"]+")',
927 video_webpage, 'age gate player URL')
928 player_url = json.loads(player_url_json)
929
930 if self._downloader.params.get('verbose'):
931 if player_url is None:
932 player_version = 'unknown'
933 player_desc = 'unknown'
934 else:
935 if player_url.endswith('swf'):
936 player_version = self._search_regex(
937 r'-(.+?)(?:/watch_as3)?\.swf$', player_url,
938 'flash player', fatal=False)
939 player_desc = 'flash player %s' % player_version
940 else:
941 player_version = self._search_regex(
942 r'html5player-([^/]+?)(?:/html5player)?\.js',
943 player_url,
944 'html5 player', fatal=False)
945 player_desc = 'html5 player %s' % player_version
946
947 parts_sizes = self._signature_cache_id(encrypted_sig)
948 self.to_screen('{%s} signature length %s, %s' %
949 (format_id, parts_sizes, player_desc))
950
951 signature = self._decrypt_signature(
952 encrypted_sig, video_id, player_url, age_gate)
953 url += '&signature=' + signature
954 if 'ratebypass' not in url:
955 url += '&ratebypass=yes'
956 url_map[format_id] = url
957 formats = _map_to_format_list(url_map)
958 elif video_info.get('hlsvp'):
959 manifest_url = video_info['hlsvp'][0]
960 url_map = self._extract_from_m3u8(manifest_url, video_id)
961 formats = _map_to_format_list(url_map)
962 else:
963 raise ExtractorError('no conn, hlsvp or url_encoded_fmt_stream_map information found in video info')
964
965 # Look for the DASH manifest
966 if self._downloader.params.get('youtube_include_dash_manifest', True):
967 try:
968 # The DASH manifest used needs to be the one from the original video_webpage.
969 # The one found in get_video_info seems to be using different signatures.
970 # However, in the case of an age restriction there won't be any embedded dashmpd in the video_webpage.
971 # Luckily, it seems, this case uses some kind of default signature (len == 86), so the
972 # combination of get_video_info and the _static_decrypt_signature() decryption fallback will work here.
973 if age_gate:
974 dash_manifest_url = video_info.get('dashmpd')[0]
975 else:
976 dash_manifest_url = ytplayer_config['args']['dashmpd']
977 def decrypt_sig(mobj):
978 s = mobj.group(1)
979 dec_s = self._decrypt_signature(s, video_id, player_url, age_gate)
980 return '/signature/%s' % dec_s
981 dash_manifest_url = re.sub(r'/s/([\w\.]+)', decrypt_sig, dash_manifest_url)
982 dash_doc = self._download_xml(
983 dash_manifest_url, video_id,
984 note='Downloading DASH manifest',
985 errnote='Could not download DASH manifest')
986 for r in dash_doc.findall('.//{urn:mpeg:DASH:schema:MPD:2011}Representation'):
987 url_el = r.find('{urn:mpeg:DASH:schema:MPD:2011}BaseURL')
988 if url_el is None:
989 continue
990 format_id = r.attrib['id']
991 video_url = url_el.text
992 filesize = int_or_none(url_el.attrib.get('{http://youtube.com/yt/2012/10/10}contentLength'))
993 f = {
994 'format_id': format_id,
995 'url': video_url,
996 'width': int_or_none(r.attrib.get('width')),
997 'tbr': int_or_none(r.attrib.get('bandwidth'), 1000),
998 'asr': int_or_none(r.attrib.get('audioSamplingRate')),
999 'filesize': filesize,
1000 }
1001 try:
1002 existing_format = next(
1003 fo for fo in formats
1004 if fo['format_id'] == format_id)
1005 except StopIteration:
1006 f.update(self._formats.get(format_id, {}))
1007 formats.append(f)
1008 else:
1009 existing_format.update(f)
1010
1011 except (ExtractorError, KeyError) as e:
1012 self.report_warning('Skipping DASH manifest: %r' % e, video_id)
1013
1014 self._sort_formats(formats)
1015
1016 return {
1017 'id': video_id,
1018 'uploader': video_uploader,
1019 'uploader_id': video_uploader_id,
1020 'upload_date': upload_date,
1021 'title': video_title,
1022 'thumbnail': video_thumbnail,
1023 'description': video_description,
1024 'categories': video_categories,
1025 'subtitles': video_subtitles,
1026 'duration': video_duration,
1027 'age_limit': 18 if age_gate else 0,
1028 'annotations': video_annotations,
1029 'webpage_url': proto + '://www.youtube.com/watch?v=%s' % video_id,
1030 'view_count': view_count,
1031 'like_count': like_count,
1032 'dislike_count': dislike_count,
1033 'formats': formats,
1034 }
1035
1036 class YoutubePlaylistIE(YoutubeBaseInfoExtractor):
1037 IE_DESC = 'YouTube.com playlists'
1038 _VALID_URL = r"""(?x)(?:
1039 (?:https?://)?
1040 (?:\w+\.)?
1041 youtube\.com/
1042 (?:
1043 (?:course|view_play_list|my_playlists|artist|playlist|watch|embed/videoseries)
1044 \? (?:.*?&)*? (?:p|a|list)=
1045 | p/
1046 )
1047 (
1048 (?:PL|LL|EC|UU|FL|RD)?[0-9A-Za-z-_]{10,}
1049 # Top tracks, they can also include dots
1050 |(?:MC)[\w\.]*
1051 )
1052 .*
1053 |
1054 ((?:PL|LL|EC|UU|FL|RD)[0-9A-Za-z-_]{10,})
1055 )"""
1056 _TEMPLATE_URL = 'https://www.youtube.com/playlist?list=%s'
1057 _MORE_PAGES_INDICATOR = r'data-link-type="next"'
1058 _VIDEO_RE = r'href="\s*/watch\?v=(?P<id>[0-9A-Za-z_-]{11})&amp;[^"]*?index=(?P<index>\d+)'
1059 IE_NAME = 'youtube:playlist'
1060 _TESTS = [{
1061 'url': 'https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1062 'info_dict': {
1063 'title': 'ytdl test PL',
1064 'id': 'PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1065 },
1066 'playlist_count': 3,
1067 }, {
1068 'url': 'https://www.youtube.com/playlist?list=PLtPgu7CB4gbZDA7i_euNxn75ISqxwZPYx',
1069 'info_dict': {
1070 'title': 'YDL_Empty_List',
1071 },
1072 'playlist_count': 0,
1073 }, {
1074 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
1075 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
1076 'info_dict': {
1077 'title': '29C3: Not my department',
1078 },
1079 'playlist_count': 95,
1080 }, {
1081 'note': 'issue #673',
1082 'url': 'PLBB231211A4F62143',
1083 'info_dict': {
1084 'title': '[OLD]Team Fortress 2 (Class-based LP)',
1085 },
1086 'playlist_mincount': 26,
1087 }, {
1088 'note': 'Large playlist',
1089 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
1090 'info_dict': {
1091 'title': 'Uploads from Cauchemar',
1092 },
1093 'playlist_mincount': 799,
1094 }, {
1095 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
1096 'info_dict': {
1097 'title': 'YDL_safe_search',
1098 },
1099 'playlist_count': 2,
1100 }, {
1101 'note': 'embedded',
1102 'url': 'http://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
1103 'playlist_count': 4,
1104 'info_dict': {
1105 'title': 'JODA15',
1106 }
1107 }, {
1108 'note': 'Embedded SWF player',
1109 'url': 'http://www.youtube.com/p/YN5VISEtHet5D4NEvfTd0zcgFk84NqFZ?hl=en_US&fs=1&rel=0',
1110 'playlist_count': 4,
1111 'info_dict': {
1112 'title': 'JODA7',
1113 }
1114 }]
1115
1116 def _real_initialize(self):
1117 self._login()
1118
1119 def _ids_to_results(self, ids):
1120 return [
1121 self.url_result(vid_id, 'Youtube', video_id=vid_id)
1122 for vid_id in ids]
1123
1124 def _extract_mix(self, playlist_id):
1125 # The mixes are generated from a a single video
1126 # the id of the playlist is just 'RD' + video_id
1127 url = 'https://youtube.com/watch?v=%s&list=%s' % (playlist_id[-11:], playlist_id)
1128 webpage = self._download_webpage(
1129 url, playlist_id, 'Downloading Youtube mix')
1130 search_title = lambda class_name: get_element_by_attribute('class', class_name, webpage)
1131 title_span = (
1132 search_title('playlist-title') or
1133 search_title('title long-title') or
1134 search_title('title'))
1135 title = clean_html(title_span)
1136 ids = orderedSet(re.findall(
1137 r'''(?xs)data-video-username=".*?".*?
1138 href="/watch\?v=([0-9A-Za-z_-]{11})&amp;[^"]*?list=%s''' % re.escape(playlist_id),
1139 webpage))
1140 url_results = self._ids_to_results(ids)
1141
1142 return self.playlist_result(url_results, playlist_id, title)
1143
1144 def _real_extract(self, url):
1145 # Extract playlist id
1146 mobj = re.match(self._VALID_URL, url)
1147 if mobj is None:
1148 raise ExtractorError('Invalid URL: %s' % url)
1149 playlist_id = mobj.group(1) or mobj.group(2)
1150
1151 # Check if it's a video-specific URL
1152 query_dict = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
1153 if 'v' in query_dict:
1154 video_id = query_dict['v'][0]
1155 if self._downloader.params.get('noplaylist'):
1156 self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
1157 return self.url_result(video_id, 'Youtube', video_id=video_id)
1158 else:
1159 self.to_screen('Downloading playlist %s - add --no-playlist to just download video %s' % (playlist_id, video_id))
1160
1161 if playlist_id.startswith('RD'):
1162 # Mixes require a custom extraction process
1163 return self._extract_mix(playlist_id)
1164 if playlist_id.startswith('TL'):
1165 raise ExtractorError('For downloading YouTube.com top lists, use '
1166 'the "yttoplist" keyword, for example "youtube-dl \'yttoplist:music:Top Tracks\'"', expected=True)
1167
1168 url = self._TEMPLATE_URL % playlist_id
1169 page = self._download_webpage(url, playlist_id)
1170 more_widget_html = content_html = page
1171
1172 # Check if the playlist exists or is private
1173 if re.search(r'<div class="yt-alert-message">[^<]*?(The|This) playlist (does not exist|is private)[^<]*?</div>', page) is not None:
1174 raise ExtractorError(
1175 'The playlist doesn\'t exist or is private, use --username or '
1176 '--netrc to access it.',
1177 expected=True)
1178
1179 # Extract the video ids from the playlist pages
1180 ids = []
1181
1182 for page_num in itertools.count(1):
1183 matches = re.finditer(self._VIDEO_RE, content_html)
1184 # We remove the duplicates and the link with index 0
1185 # (it's not the first video of the playlist)
1186 new_ids = orderedSet(m.group('id') for m in matches if m.group('index') != '0')
1187 ids.extend(new_ids)
1188
1189 mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
1190 if not mobj:
1191 break
1192
1193 more = self._download_json(
1194 'https://youtube.com/%s' % mobj.group('more'), playlist_id,
1195 'Downloading page #%s' % page_num,
1196 transform_source=uppercase_escape)
1197 content_html = more['content_html']
1198 more_widget_html = more['load_more_widget_html']
1199
1200 playlist_title = self._html_search_regex(
1201 r'(?s)<h1 class="pl-header-title[^"]*">\s*(.*?)\s*</h1>',
1202 page, 'title')
1203
1204 url_results = self._ids_to_results(ids)
1205 return self.playlist_result(url_results, playlist_id, playlist_title)
1206
1207
1208 class YoutubeTopListIE(YoutubePlaylistIE):
1209 IE_NAME = 'youtube:toplist'
1210 IE_DESC = ('YouTube.com top lists, "yttoplist:{channel}:{list title}"'
1211 ' (Example: "yttoplist:music:Top Tracks")')
1212 _VALID_URL = r'yttoplist:(?P<chann>.*?):(?P<title>.*?)$'
1213 _TESTS = [{
1214 'url': 'yttoplist:music:Trending',
1215 'playlist_mincount': 5,
1216 'skip': 'Only works for logged-in users',
1217 }]
1218
1219 def _real_extract(self, url):
1220 mobj = re.match(self._VALID_URL, url)
1221 channel = mobj.group('chann')
1222 title = mobj.group('title')
1223 query = compat_urllib_parse.urlencode({'title': title})
1224 channel_page = self._download_webpage(
1225 'https://www.youtube.com/%s' % channel, title)
1226 link = self._html_search_regex(
1227 r'''(?x)
1228 <a\s+href="([^"]+)".*?>\s*
1229 <span\s+class="branded-page-module-title-text">\s*
1230 <span[^>]*>.*?%s.*?</span>''' % re.escape(query),
1231 channel_page, 'list')
1232 url = compat_urlparse.urljoin('https://www.youtube.com/', link)
1233
1234 video_re = r'data-index="\d+".*?data-video-id="([0-9A-Za-z_-]{11})"'
1235 ids = []
1236 # sometimes the webpage doesn't contain the videos
1237 # retry until we get them
1238 for i in itertools.count(0):
1239 msg = 'Downloading Youtube mix'
1240 if i > 0:
1241 msg += ', retry #%d' % i
1242
1243 webpage = self._download_webpage(url, title, msg)
1244 ids = orderedSet(re.findall(video_re, webpage))
1245 if ids:
1246 break
1247 url_results = self._ids_to_results(ids)
1248 return self.playlist_result(url_results, playlist_title=title)
1249
1250
1251 class YoutubeChannelIE(InfoExtractor):
1252 IE_DESC = 'YouTube.com channels'
1253 _VALID_URL = r"^(?:https?://)?(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/([0-9A-Za-z_-]+)"
1254 _MORE_PAGES_INDICATOR = 'yt-uix-load-more'
1255 _MORE_PAGES_URL = 'https://www.youtube.com/c4_browse_ajax?action_load_more_videos=1&flow=list&paging=%s&view=0&sort=da&channel_id=%s'
1256 IE_NAME = 'youtube:channel'
1257 _TESTS = [{
1258 'note': 'paginated channel',
1259 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
1260 'playlist_mincount': 91,
1261 }]
1262
1263 def extract_videos_from_page(self, page):
1264 ids_in_page = []
1265 for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&?', page):
1266 if mobj.group(1) not in ids_in_page:
1267 ids_in_page.append(mobj.group(1))
1268 return ids_in_page
1269
1270 def _real_extract(self, url):
1271 # Extract channel id
1272 mobj = re.match(self._VALID_URL, url)
1273 if mobj is None:
1274 raise ExtractorError('Invalid URL: %s' % url)
1275
1276 # Download channel page
1277 channel_id = mobj.group(1)
1278 video_ids = []
1279 url = 'https://www.youtube.com/channel/%s/videos' % channel_id
1280 channel_page = self._download_webpage(url, channel_id)
1281 autogenerated = re.search(r'''(?x)
1282 class="[^"]*?(?:
1283 channel-header-autogenerated-label|
1284 yt-channel-title-autogenerated
1285 )[^"]*"''', channel_page) is not None
1286
1287 if autogenerated:
1288 # The videos are contained in a single page
1289 # the ajax pages can't be used, they are empty
1290 video_ids = self.extract_videos_from_page(channel_page)
1291 else:
1292 # Download all channel pages using the json-based channel_ajax query
1293 for pagenum in itertools.count(1):
1294 url = self._MORE_PAGES_URL % (pagenum, channel_id)
1295 page = self._download_json(
1296 url, channel_id, note='Downloading page #%s' % pagenum,
1297 transform_source=uppercase_escape)
1298
1299 ids_in_page = self.extract_videos_from_page(page['content_html'])
1300 video_ids.extend(ids_in_page)
1301
1302 if self._MORE_PAGES_INDICATOR not in page['load_more_widget_html']:
1303 break
1304
1305 self._downloader.to_screen('[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
1306
1307 url_entries = [self.url_result(video_id, 'Youtube', video_id=video_id)
1308 for video_id in video_ids]
1309 return self.playlist_result(url_entries, channel_id)
1310
1311
1312 class YoutubeUserIE(InfoExtractor):
1313 IE_DESC = 'YouTube.com user videos (URL or "ytuser" keyword)'
1314 _VALID_URL = r'(?:(?:(?:https?://)?(?:\w+\.)?youtube\.com/(?:user/)?(?!(?:attribution_link|watch|results)(?:$|[^a-z_A-Z0-9-])))|ytuser:)(?!feed/)([A-Za-z0-9_-]+)'
1315 _TEMPLATE_URL = 'https://gdata.youtube.com/feeds/api/users/%s'
1316 _GDATA_PAGE_SIZE = 50
1317 _GDATA_URL = 'https://gdata.youtube.com/feeds/api/users/%s/uploads?max-results=%d&start-index=%d&alt=json'
1318 IE_NAME = 'youtube:user'
1319
1320 _TESTS = [{
1321 'url': 'https://www.youtube.com/user/TheLinuxFoundation',
1322 'playlist_mincount': 320,
1323 'info_dict': {
1324 'title': 'TheLinuxFoundation',
1325 }
1326 }, {
1327 'url': 'ytuser:phihag',
1328 'only_matching': True,
1329 }]
1330
1331 @classmethod
1332 def suitable(cls, url):
1333 # Don't return True if the url can be extracted with other youtube
1334 # extractor, the regex would is too permissive and it would match.
1335 other_ies = iter(klass for (name, klass) in globals().items() if name.endswith('IE') and klass is not cls)
1336 if any(ie.suitable(url) for ie in other_ies): return False
1337 else: return super(YoutubeUserIE, cls).suitable(url)
1338
1339 def _real_extract(self, url):
1340 # Extract username
1341 mobj = re.match(self._VALID_URL, url)
1342 if mobj is None:
1343 raise ExtractorError('Invalid URL: %s' % url)
1344
1345 username = mobj.group(1)
1346
1347 # Download video ids using YouTube Data API. Result size per
1348 # query is limited (currently to 50 videos) so we need to query
1349 # page by page until there are no video ids - it means we got
1350 # all of them.
1351
1352 def download_page(pagenum):
1353 start_index = pagenum * self._GDATA_PAGE_SIZE + 1
1354
1355 gdata_url = self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index)
1356 page = self._download_webpage(
1357 gdata_url, username,
1358 'Downloading video ids from %d to %d' % (
1359 start_index, start_index + self._GDATA_PAGE_SIZE))
1360
1361 try:
1362 response = json.loads(page)
1363 except ValueError as err:
1364 raise ExtractorError('Invalid JSON in API response: ' + compat_str(err))
1365 if 'entry' not in response['feed']:
1366 return
1367
1368 # Extract video identifiers
1369 entries = response['feed']['entry']
1370 for entry in entries:
1371 title = entry['title']['$t']
1372 video_id = entry['id']['$t'].split('/')[-1]
1373 yield {
1374 '_type': 'url',
1375 'url': video_id,
1376 'ie_key': 'Youtube',
1377 'id': video_id,
1378 'title': title,
1379 }
1380 url_results = OnDemandPagedList(download_page, self._GDATA_PAGE_SIZE)
1381
1382 return self.playlist_result(url_results, playlist_title=username)
1383
1384
1385 class YoutubeSearchIE(SearchInfoExtractor):
1386 IE_DESC = 'YouTube.com searches'
1387 _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc'
1388 _MAX_RESULTS = 1000
1389 IE_NAME = 'youtube:search'
1390 _SEARCH_KEY = 'ytsearch'
1391
1392 def _get_n_results(self, query, n):
1393 """Get a specified number of results for a query"""
1394
1395 video_ids = []
1396 pagenum = 0
1397 limit = n
1398 PAGE_SIZE = 50
1399
1400 while (PAGE_SIZE * pagenum) < limit:
1401 result_url = self._API_URL % (
1402 compat_urllib_parse.quote_plus(query.encode('utf-8')),
1403 (PAGE_SIZE * pagenum) + 1)
1404 data_json = self._download_webpage(
1405 result_url, video_id='query "%s"' % query,
1406 note='Downloading page %s' % (pagenum + 1),
1407 errnote='Unable to download API page')
1408 data = json.loads(data_json)
1409 api_response = data['data']
1410
1411 if 'items' not in api_response:
1412 raise ExtractorError(
1413 '[youtube] No video results', expected=True)
1414
1415 new_ids = list(video['id'] for video in api_response['items'])
1416 video_ids += new_ids
1417
1418 limit = min(n, api_response['totalItems'])
1419 pagenum += 1
1420
1421 if len(video_ids) > n:
1422 video_ids = video_ids[:n]
1423 videos = [self.url_result(video_id, 'Youtube', video_id=video_id)
1424 for video_id in video_ids]
1425 return self.playlist_result(videos, query)
1426
1427
1428 class YoutubeSearchDateIE(YoutubeSearchIE):
1429 IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
1430 _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc&orderby=published'
1431 _SEARCH_KEY = 'ytsearchdate'
1432 IE_DESC = 'YouTube.com searches, newest videos first'
1433
1434
1435 class YoutubeSearchURLIE(InfoExtractor):
1436 IE_DESC = 'YouTube.com search URLs'
1437 IE_NAME = 'youtube:search_url'
1438 _VALID_URL = r'https?://(?:www\.)?youtube\.com/results\?(.*?&)?search_query=(?P<query>[^&]+)(?:[&]|$)'
1439 _TESTS = [{
1440 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
1441 'playlist_mincount': 5,
1442 'info_dict': {
1443 'title': 'youtube-dl test video',
1444 }
1445 }]
1446
1447 def _real_extract(self, url):
1448 mobj = re.match(self._VALID_URL, url)
1449 query = compat_urllib_parse.unquote_plus(mobj.group('query'))
1450
1451 webpage = self._download_webpage(url, query)
1452 result_code = self._search_regex(
1453 r'(?s)<ol class="item-section"(.*?)</ol>', webpage, 'result HTML')
1454
1455 part_codes = re.findall(
1456 r'(?s)<h3 class="yt-lockup-title">(.*?)</h3>', result_code)
1457 entries = []
1458 for part_code in part_codes:
1459 part_title = self._html_search_regex(
1460 [r'(?s)title="([^"]+)"', r'>([^<]+)</a>'], part_code, 'item title', fatal=False)
1461 part_url_snippet = self._html_search_regex(
1462 r'(?s)href="([^"]+)"', part_code, 'item URL')
1463 part_url = compat_urlparse.urljoin(
1464 'https://www.youtube.com/', part_url_snippet)
1465 entries.append({
1466 '_type': 'url',
1467 'url': part_url,
1468 'title': part_title,
1469 })
1470
1471 return {
1472 '_type': 'playlist',
1473 'entries': entries,
1474 'title': query,
1475 }
1476
1477
1478 class YoutubeShowIE(InfoExtractor):
1479 IE_DESC = 'YouTube.com (multi-season) shows'
1480 _VALID_URL = r'https?://www\.youtube\.com/show/(?P<id>[^?#]*)'
1481 IE_NAME = 'youtube:show'
1482 _TESTS = [{
1483 'url': 'http://www.youtube.com/show/airdisasters',
1484 'playlist_mincount': 3,
1485 'info_dict': {
1486 'id': 'airdisasters',
1487 'title': 'Air Disasters',
1488 }
1489 }]
1490
1491 def _real_extract(self, url):
1492 mobj = re.match(self._VALID_URL, url)
1493 playlist_id = mobj.group('id')
1494 webpage = self._download_webpage(
1495 url, playlist_id, 'Downloading show webpage')
1496 # There's one playlist for each season of the show
1497 m_seasons = list(re.finditer(r'href="(/playlist\?list=.*?)"', webpage))
1498 self.to_screen('%s: Found %s seasons' % (playlist_id, len(m_seasons)))
1499 entries = [
1500 self.url_result(
1501 'https://www.youtube.com' + season.group(1), 'YoutubePlaylist')
1502 for season in m_seasons
1503 ]
1504 title = self._og_search_title(webpage, fatal=False)
1505
1506 return {
1507 '_type': 'playlist',
1508 'id': playlist_id,
1509 'title': title,
1510 'entries': entries,
1511 }
1512
1513
1514 class YoutubeFeedsInfoExtractor(YoutubeBaseInfoExtractor):
1515 """
1516 Base class for extractors that fetch info from
1517 http://www.youtube.com/feed_ajax
1518 Subclasses must define the _FEED_NAME and _PLAYLIST_TITLE properties.
1519 """
1520 _LOGIN_REQUIRED = True
1521 # use action_load_personal_feed instead of action_load_system_feed
1522 _PERSONAL_FEED = False
1523
1524 @property
1525 def _FEED_TEMPLATE(self):
1526 action = 'action_load_system_feed'
1527 if self._PERSONAL_FEED:
1528 action = 'action_load_personal_feed'
1529 return 'https://www.youtube.com/feed_ajax?%s=1&feed_name=%s&paging=%%s' % (action, self._FEED_NAME)
1530
1531 @property
1532 def IE_NAME(self):
1533 return 'youtube:%s' % self._FEED_NAME
1534
1535 def _real_initialize(self):
1536 self._login()
1537
1538 def _real_extract(self, url):
1539 feed_entries = []
1540 paging = 0
1541 for i in itertools.count(1):
1542 info = self._download_json(self._FEED_TEMPLATE % paging,
1543 '%s feed' % self._FEED_NAME,
1544 'Downloading page %s' % i)
1545 feed_html = info.get('feed_html') or info.get('content_html')
1546 load_more_widget_html = info.get('load_more_widget_html') or feed_html
1547 m_ids = re.finditer(r'"/watch\?v=(.*?)["&]', feed_html)
1548 ids = orderedSet(m.group(1) for m in m_ids)
1549 feed_entries.extend(
1550 self.url_result(video_id, 'Youtube', video_id=video_id)
1551 for video_id in ids)
1552 mobj = re.search(
1553 r'data-uix-load-more-href="/?[^"]+paging=(?P<paging>\d+)',
1554 load_more_widget_html)
1555 if mobj is None:
1556 break
1557 paging = mobj.group('paging')
1558 return self.playlist_result(feed_entries, playlist_title=self._PLAYLIST_TITLE)
1559
1560 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
1561 IE_DESC = 'YouTube.com recommended videos, "ytrec" keyword (requires authentication)'
1562 _VALID_URL = r'https?://www\.youtube\.com/feed/recommended|:ytrec(?:ommended)?'
1563 _FEED_NAME = 'recommended'
1564 _PLAYLIST_TITLE = 'Youtube Recommended videos'
1565
1566 class YoutubeWatchLaterIE(YoutubeFeedsInfoExtractor):
1567 IE_DESC = 'Youtube watch later list, "ytwatchlater" keyword (requires authentication)'
1568 _VALID_URL = r'https?://www\.youtube\.com/feed/watch_later|:ytwatchlater'
1569 _FEED_NAME = 'watch_later'
1570 _PLAYLIST_TITLE = 'Youtube Watch Later'
1571 _PERSONAL_FEED = True
1572
1573 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
1574 IE_DESC = 'Youtube watch history, "ythistory" keyword (requires authentication)'
1575 _VALID_URL = 'https?://www\.youtube\.com/feed/history|:ythistory'
1576 _FEED_NAME = 'history'
1577 _PERSONAL_FEED = True
1578 _PLAYLIST_TITLE = 'Youtube Watch History'
1579
1580 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
1581 IE_NAME = 'youtube:favorites'
1582 IE_DESC = 'YouTube.com favourite videos, "ytfav" keyword (requires authentication)'
1583 _VALID_URL = r'https?://www\.youtube\.com/my_favorites|:ytfav(?:ou?rites)?'
1584 _LOGIN_REQUIRED = True
1585
1586 def _real_extract(self, url):
1587 webpage = self._download_webpage('https://www.youtube.com/my_favorites', 'Youtube Favourites videos')
1588 playlist_id = self._search_regex(r'list=(.+?)["&]', webpage, 'favourites playlist id')
1589 return self.url_result(playlist_id, 'YoutubePlaylist')
1590
1591
1592 class YoutubeSubscriptionsIE(YoutubePlaylistIE):
1593 IE_NAME = 'youtube:subscriptions'
1594 IE_DESC = 'YouTube.com subscriptions feed, "ytsubs" keyword (requires authentication)'
1595 _VALID_URL = r'https?://www\.youtube\.com/feed/subscriptions|:ytsubs(?:criptions)?'
1596 _TESTS = []
1597
1598 def _real_extract(self, url):
1599 title = 'Youtube Subscriptions'
1600 page = self._download_webpage('https://www.youtube.com/feed/subscriptions', title)
1601
1602 # The extraction process is the same as for playlists, but the regex
1603 # for the video ids doesn't contain an index
1604 ids = []
1605 more_widget_html = content_html = page
1606
1607 for page_num in itertools.count(1):
1608 matches = re.findall(r'href="\s*/watch\?v=([0-9A-Za-z_-]{11})', content_html)
1609 new_ids = orderedSet(matches)
1610 ids.extend(new_ids)
1611
1612 mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
1613 if not mobj:
1614 break
1615
1616 more = self._download_json(
1617 'https://youtube.com/%s' % mobj.group('more'), title,
1618 'Downloading page #%s' % page_num,
1619 transform_source=uppercase_escape)
1620 content_html = more['content_html']
1621 more_widget_html = more['load_more_widget_html']
1622
1623 return {
1624 '_type': 'playlist',
1625 'title': title,
1626 'entries': self._ids_to_results(ids),
1627 }
1628
1629
1630 class YoutubeTruncatedURLIE(InfoExtractor):
1631 IE_NAME = 'youtube:truncated_url'
1632 IE_DESC = False # Do not list
1633 _VALID_URL = r'''(?x)
1634 (?:https?://)?[^/]+/watch\?(?:
1635 feature=[a-z_]+|
1636 annotation_id=annotation_[^&]+
1637 )?$|
1638 (?:https?://)?(?:www\.)?youtube\.com/attribution_link\?a=[^&]+$
1639 '''
1640
1641 _TESTS = [{
1642 'url': 'http://www.youtube.com/watch?annotation_id=annotation_3951667041',
1643 'only_matching': True,
1644 }, {
1645 'url': 'http://www.youtube.com/watch?',
1646 'only_matching': True,
1647 }]
1648
1649 def _real_extract(self, url):
1650 raise ExtractorError(
1651 'Did you forget to quote the URL? Remember that & is a meta '
1652 'character in most shells, so you want to put the URL in quotes, '
1653 'like youtube-dl '
1654 '"http://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
1655 ' or simply youtube-dl BaW_jenozKc .',
1656 expected=True)
Backup clone of https://github.com/ytdl-org unavailable since RIAA fucking raid...