You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1769 lines
76 KiB

11 years ago
  1. # coding: utf-8
  2. import collections
  3. import errno
  4. import io
  5. import itertools
  6. import json
  7. import os.path
  8. import re
  9. import string
  10. import struct
  11. import traceback
  12. import zlib
  13. from .common import InfoExtractor, SearchInfoExtractor
  14. from .subtitles import SubtitlesInfoExtractor
  15. from ..utils import (
  16. compat_chr,
  17. compat_parse_qs,
  18. compat_urllib_parse,
  19. compat_urllib_request,
  20. compat_urlparse,
  21. compat_str,
  22. clean_html,
  23. get_cachedir,
  24. get_element_by_id,
  25. get_element_by_attribute,
  26. ExtractorError,
  27. unescapeHTML,
  28. unified_strdate,
  29. orderedSet,
  30. write_json_file,
  31. )
  32. class YoutubeBaseInfoExtractor(InfoExtractor):
  33. """Provide base functions for Youtube extractors"""
  34. _LOGIN_URL = 'https://accounts.google.com/ServiceLogin'
  35. _LANG_URL = r'https://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
  36. _AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
  37. _NETRC_MACHINE = 'youtube'
  38. # If True it will raise an error if no login info is provided
  39. _LOGIN_REQUIRED = False
  40. def _set_language(self):
  41. return bool(self._download_webpage(
  42. self._LANG_URL, None,
  43. note=u'Setting language', errnote='unable to set language',
  44. fatal=False))
  45. def _login(self):
  46. (username, password) = self._get_login_info()
  47. # No authentication to be performed
  48. if username is None:
  49. if self._LOGIN_REQUIRED:
  50. raise ExtractorError(u'No login info available, needed for using %s.' % self.IE_NAME, expected=True)
  51. return False
  52. login_page = self._download_webpage(
  53. self._LOGIN_URL, None,
  54. note=u'Downloading login page',
  55. errnote=u'unable to fetch login page', fatal=False)
  56. if login_page is False:
  57. return
  58. galx = self._search_regex(r'(?s)<input.+?name="GALX".+?value="(.+?)"',
  59. login_page, u'Login GALX parameter')
  60. # Log in
  61. login_form_strs = {
  62. u'continue': u'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
  63. u'Email': username,
  64. u'GALX': galx,
  65. u'Passwd': password,
  66. u'PersistentCookie': u'yes',
  67. u'_utf8': u'',
  68. u'bgresponse': u'js_disabled',
  69. u'checkConnection': u'',
  70. u'checkedDomains': u'youtube',
  71. u'dnConn': u'',
  72. u'pstMsg': u'0',
  73. u'rmShown': u'1',
  74. u'secTok': u'',
  75. u'signIn': u'Sign in',
  76. u'timeStmp': u'',
  77. u'service': u'youtube',
  78. u'uilel': u'3',
  79. u'hl': u'en_US',
  80. }
  81. # Convert to UTF-8 *before* urlencode because Python 2.x's urlencode
  82. # chokes on unicode
  83. login_form = dict((k.encode('utf-8'), v.encode('utf-8')) for k,v in login_form_strs.items())
  84. login_data = compat_urllib_parse.urlencode(login_form).encode('ascii')
  85. req = compat_urllib_request.Request(self._LOGIN_URL, login_data)
  86. login_results = self._download_webpage(
  87. req, None,
  88. note=u'Logging in', errnote=u'unable to log in', fatal=False)
  89. if login_results is False:
  90. return False
  91. if re.search(r'(?i)<form[^>]* id="gaia_loginform"', login_results) is not None:
  92. self._downloader.report_warning(u'unable to log in: bad username or password')
  93. return False
  94. return True
  95. def _confirm_age(self):
  96. age_form = {
  97. 'next_url': '/',
  98. 'action_confirm': 'Confirm',
  99. }
  100. req = compat_urllib_request.Request(self._AGE_URL, compat_urllib_parse.urlencode(age_form))
  101. self._download_webpage(
  102. req, None,
  103. note=u'Confirming age', errnote=u'Unable to confirm age')
  104. return True
  105. def _real_initialize(self):
  106. if self._downloader is None:
  107. return
  108. if not self._set_language():
  109. return
  110. if not self._login():
  111. return
  112. self._confirm_age()
  113. class YoutubeIE(YoutubeBaseInfoExtractor, SubtitlesInfoExtractor):
  114. IE_DESC = u'YouTube.com'
  115. _VALID_URL = r"""(?x)^
  116. (
  117. (?:https?://|//)? # http(s):// or protocol-independent URL (optional)
  118. (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/|
  119. (?:www\.)?deturl\.com/www\.youtube\.com/|
  120. (?:www\.)?pwnyoutube\.com|
  121. tube\.majestyc\.net/|
  122. youtube\.googleapis\.com/) # the various hostnames, with wildcard subdomains
  123. (?:.*?\#/)? # handle anchor (#/) redirect urls
  124. (?: # the various things that can precede the ID:
  125. (?:(?:v|embed|e)/) # v/ or embed/ or e/
  126. |(?: # or the v= param in all its forms
  127. (?:(?:watch|movie)(?:_popup)?(?:\.php)?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
  128. (?:\?|\#!?) # the params delimiter ? or # or #!
  129. (?:.*?&)? # any other preceding param (like /?s=tuff&v=xxxx)
  130. v=
  131. )
  132. ))
  133. |youtu\.be/ # just youtu.be/xxxx
  134. )
  135. )? # all until now is optional -> you can pass the naked ID
  136. ([0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
  137. (?(1).+)? # if we found the ID, everything can follow
  138. $"""
  139. _NEXT_URL_RE = r'[\?&]next_url=([^&]+)'
  140. _formats = {
  141. '5': {'ext': 'flv', 'width': 400, 'height': 240},
  142. '6': {'ext': 'flv', 'width': 450, 'height': 270},
  143. '13': {'ext': '3gp'},
  144. '17': {'ext': '3gp', 'width': 176, 'height': 144},
  145. '18': {'ext': 'mp4', 'width': 640, 'height': 360},
  146. '22': {'ext': 'mp4', 'width': 1280, 'height': 720},
  147. '34': {'ext': 'flv', 'width': 640, 'height': 360},
  148. '35': {'ext': 'flv', 'width': 854, 'height': 480},
  149. '36': {'ext': '3gp', 'width': 320, 'height': 240},
  150. '37': {'ext': 'mp4', 'width': 1920, 'height': 1080},
  151. '38': {'ext': 'mp4', 'width': 4096, 'height': 3072},
  152. '43': {'ext': 'webm', 'width': 640, 'height': 360},
  153. '44': {'ext': 'webm', 'width': 854, 'height': 480},
  154. '45': {'ext': 'webm', 'width': 1280, 'height': 720},
  155. '46': {'ext': 'webm', 'width': 1920, 'height': 1080},
  156. # 3d videos
  157. '82': {'ext': 'mp4', 'height': 360, 'resolution': '360p', 'format_note': '3D', 'preference': -20},
  158. '83': {'ext': 'mp4', 'height': 480, 'resolution': '480p', 'format_note': '3D', 'preference': -20},
  159. '84': {'ext': 'mp4', 'height': 720, 'resolution': '720p', 'format_note': '3D', 'preference': -20},
  160. '85': {'ext': 'mp4', 'height': 1080, 'resolution': '1080p', 'format_note': '3D', 'preference': -20},
  161. '100': {'ext': 'webm', 'height': 360, 'resolution': '360p', 'format_note': '3D', 'preference': -20},
  162. '101': {'ext': 'webm', 'height': 480, 'resolution': '480p', 'format_note': '3D', 'preference': -20},
  163. '102': {'ext': 'webm', 'height': 720, 'resolution': '720p', 'format_note': '3D', 'preference': -20},
  164. # Apple HTTP Live Streaming
  165. '92': {'ext': 'mp4', 'height': 240, 'resolution': '240p', 'format_note': 'HLS', 'preference': -10},
  166. '93': {'ext': 'mp4', 'height': 360, 'resolution': '360p', 'format_note': 'HLS', 'preference': -10},
  167. '94': {'ext': 'mp4', 'height': 480, 'resolution': '480p', 'format_note': 'HLS', 'preference': -10},
  168. '95': {'ext': 'mp4', 'height': 720, 'resolution': '720p', 'format_note': 'HLS', 'preference': -10},
  169. '96': {'ext': 'mp4', 'height': 1080, 'resolution': '1080p', 'format_note': 'HLS', 'preference': -10},
  170. '132': {'ext': 'mp4', 'height': 240, 'resolution': '240p', 'format_note': 'HLS', 'preference': -10},
  171. '151': {'ext': 'mp4', 'height': 72, 'resolution': '72p', 'format_note': 'HLS', 'preference': -10},
  172. # DASH mp4 video
  173. '133': {'ext': 'mp4', 'height': 240, 'resolution': '240p', 'format_note': 'DASH video', 'preference': -40},
  174. '134': {'ext': 'mp4', 'height': 360, 'resolution': '360p', 'format_note': 'DASH video', 'preference': -40},
  175. '135': {'ext': 'mp4', 'height': 480, 'resolution': '480p', 'format_note': 'DASH video', 'preference': -40},
  176. '136': {'ext': 'mp4', 'height': 720, 'resolution': '720p', 'format_note': 'DASH video', 'preference': -40},
  177. '137': {'ext': 'mp4', 'height': 1080, 'resolution': '1080p', 'format_note': 'DASH video', 'preference': -40},
  178. '138': {'ext': 'mp4', 'height': 1081, 'resolution': '>1080p', 'format_note': 'DASH video', 'preference': -40},
  179. '160': {'ext': 'mp4', 'height': 192, 'resolution': '192p', 'format_note': 'DASH video', 'preference': -40},
  180. '264': {'ext': 'mp4', 'height': 1080, 'resolution': '1080p', 'format_note': 'DASH video', 'preference': -40},
  181. # Dash mp4 audio
  182. '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 48, 'preference': -50},
  183. '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 128, 'preference': -50},
  184. '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 256, 'preference': -50},
  185. # Dash webm
  186. '242': {'ext': 'webm', 'height': 240, 'resolution': '240p', 'format_note': 'DASH webm', 'preference': -40},
  187. '243': {'ext': 'webm', 'height': 360, 'resolution': '360p', 'format_note': 'DASH webm', 'preference': -40},
  188. '244': {'ext': 'webm', 'height': 480, 'resolution': '480p', 'format_note': 'DASH webm', 'preference': -40},
  189. '245': {'ext': 'webm', 'height': 480, 'resolution': '480p', 'format_note': 'DASH webm', 'preference': -40},
  190. '246': {'ext': 'webm', 'height': 480, 'resolution': '480p', 'format_note': 'DASH webm', 'preference': -40},
  191. '247': {'ext': 'webm', 'height': 720, 'resolution': '720p', 'format_note': 'DASH webm', 'preference': -40},
  192. '248': {'ext': 'webm', 'height': 1080, 'resolution': '1080p', 'format_note': 'DASH webm', 'preference': -40},
  193. # Dash webm audio
  194. '171': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH webm audio', 'abr': 48, 'preference': -50},
  195. '172': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH webm audio', 'abr': 256, 'preference': -50},
  196. # RTMP (unnamed)
  197. '_rtmp': {'protocol': 'rtmp'},
  198. }
  199. IE_NAME = u'youtube'
  200. _TESTS = [
  201. {
  202. u"url": u"http://www.youtube.com/watch?v=BaW_jenozKc",
  203. u"file": u"BaW_jenozKc.mp4",
  204. u"info_dict": {
  205. u"title": u"youtube-dl test video \"'/\\ä↭𝕐",
  206. u"uploader": u"Philipp Hagemeister",
  207. u"uploader_id": u"phihag",
  208. u"upload_date": u"20121002",
  209. u"description": u"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 ."
  210. }
  211. },
  212. {
  213. u"url": u"http://www.youtube.com/watch?v=UxxajLWwzqY",
  214. u"file": u"UxxajLWwzqY.mp4",
  215. u"note": u"Test generic use_cipher_signature video (#897)",
  216. u"info_dict": {
  217. u"upload_date": u"20120506",
  218. u"title": u"Icona Pop - I Love It (feat. Charli XCX) [OFFICIAL VIDEO]",
  219. u"description": u"md5:5b292926389560516e384ac437c0ec07",
  220. u"uploader": u"Icona Pop",
  221. u"uploader_id": u"IconaPop"
  222. }
  223. },
  224. {
  225. u"url": u"https://www.youtube.com/watch?v=07FYdnEawAQ",
  226. u"file": u"07FYdnEawAQ.mp4",
  227. u"note": u"Test VEVO video with age protection (#956)",
  228. u"info_dict": {
  229. u"upload_date": u"20130703",
  230. u"title": u"Justin Timberlake - Tunnel Vision (Explicit)",
  231. u"description": u"md5:64249768eec3bc4276236606ea996373",
  232. u"uploader": u"justintimberlakeVEVO",
  233. u"uploader_id": u"justintimberlakeVEVO"
  234. }
  235. },
  236. {
  237. u"url": u"//www.YouTube.com/watch?v=yZIXLfi8CZQ",
  238. u"file": u"yZIXLfi8CZQ.mp4",
  239. u"note": u"Embed-only video (#1746)",
  240. u"info_dict": {
  241. u"upload_date": u"20120608",
  242. u"title": u"Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012",
  243. u"description": u"md5:09b78bd971f1e3e289601dfba15ca4f7",
  244. u"uploader": u"SET India",
  245. u"uploader_id": u"setindia"
  246. }
  247. },
  248. ]
  249. @classmethod
  250. def suitable(cls, url):
  251. """Receives a URL and returns True if suitable for this IE."""
  252. if YoutubePlaylistIE.suitable(url): return False
  253. return re.match(cls._VALID_URL, url) is not None
  254. def __init__(self, *args, **kwargs):
  255. super(YoutubeIE, self).__init__(*args, **kwargs)
  256. self._player_cache = {}
  257. def report_video_info_webpage_download(self, video_id):
  258. """Report attempt to download video info webpage."""
  259. self.to_screen(u'%s: Downloading video info webpage' % video_id)
  260. def report_information_extraction(self, video_id):
  261. """Report attempt to extract video information."""
  262. self.to_screen(u'%s: Extracting video information' % video_id)
  263. def report_unavailable_format(self, video_id, format):
  264. """Report extracted video URL."""
  265. self.to_screen(u'%s: Format %s not available' % (video_id, format))
  266. def report_rtmp_download(self):
  267. """Indicate the download will use the RTMP protocol."""
  268. self.to_screen(u'RTMP download detected')
  269. def _extract_signature_function(self, video_id, player_url, slen):
  270. id_m = re.match(r'.*-(?P<id>[a-zA-Z0-9_-]+)\.(?P<ext>[a-z]+)$',
  271. player_url)
  272. player_type = id_m.group('ext')
  273. player_id = id_m.group('id')
  274. # Read from filesystem cache
  275. func_id = '%s_%s_%d' % (player_type, player_id, slen)
  276. assert os.path.basename(func_id) == func_id
  277. cache_dir = get_cachedir(self._downloader.params)
  278. cache_enabled = cache_dir is not None
  279. if cache_enabled:
  280. cache_fn = os.path.join(os.path.expanduser(cache_dir),
  281. u'youtube-sigfuncs',
  282. func_id + '.json')
  283. try:
  284. with io.open(cache_fn, 'r', encoding='utf-8') as cachef:
  285. cache_spec = json.load(cachef)
  286. return lambda s: u''.join(s[i] for i in cache_spec)
  287. except IOError:
  288. pass # No cache available
  289. if player_type == 'js':
  290. code = self._download_webpage(
  291. player_url, video_id,
  292. note=u'Downloading %s player %s' % (player_type, player_id),
  293. errnote=u'Download of %s failed' % player_url)
  294. res = self._parse_sig_js(code)
  295. elif player_type == 'swf':
  296. urlh = self._request_webpage(
  297. player_url, video_id,
  298. note=u'Downloading %s player %s' % (player_type, player_id),
  299. errnote=u'Download of %s failed' % player_url)
  300. code = urlh.read()
  301. res = self._parse_sig_swf(code)
  302. else:
  303. assert False, 'Invalid player type %r' % player_type
  304. if cache_enabled:
  305. try:
  306. test_string = u''.join(map(compat_chr, range(slen)))
  307. cache_res = res(test_string)
  308. cache_spec = [ord(c) for c in cache_res]
  309. try:
  310. os.makedirs(os.path.dirname(cache_fn))
  311. except OSError as ose:
  312. if ose.errno != errno.EEXIST:
  313. raise
  314. write_json_file(cache_spec, cache_fn)
  315. except Exception:
  316. tb = traceback.format_exc()
  317. self._downloader.report_warning(
  318. u'Writing cache to %r failed: %s' % (cache_fn, tb))
  319. return res
  320. def _print_sig_code(self, func, slen):
  321. def gen_sig_code(idxs):
  322. def _genslice(start, end, step):
  323. starts = u'' if start == 0 else str(start)
  324. ends = (u':%d' % (end+step)) if end + step >= 0 else u':'
  325. steps = u'' if step == 1 else (u':%d' % step)
  326. return u's[%s%s%s]' % (starts, ends, steps)
  327. step = None
  328. start = '(Never used)' # Quelch pyflakes warnings - start will be
  329. # set as soon as step is set
  330. for i, prev in zip(idxs[1:], idxs[:-1]):
  331. if step is not None:
  332. if i - prev == step:
  333. continue
  334. yield _genslice(start, prev, step)
  335. step = None
  336. continue
  337. if i - prev in [-1, 1]:
  338. step = i - prev
  339. start = prev
  340. continue
  341. else:
  342. yield u's[%d]' % prev
  343. if step is None:
  344. yield u's[%d]' % i
  345. else:
  346. yield _genslice(start, i, step)
  347. test_string = u''.join(map(compat_chr, range(slen)))
  348. cache_res = func(test_string)
  349. cache_spec = [ord(c) for c in cache_res]
  350. expr_code = u' + '.join(gen_sig_code(cache_spec))
  351. code = u'if len(s) == %d:\n return %s\n' % (slen, expr_code)
  352. self.to_screen(u'Extracted signature function:\n' + code)
  353. def _parse_sig_js(self, jscode):
  354. funcname = self._search_regex(
  355. r'signature=([a-zA-Z]+)', jscode,
  356. u'Initial JS player signature function name')
  357. functions = {}
  358. def argidx(varname):
  359. return string.lowercase.index(varname)
  360. def interpret_statement(stmt, local_vars, allow_recursion=20):
  361. if allow_recursion < 0:
  362. raise ExtractorError(u'Recursion limit reached')
  363. if stmt.startswith(u'var '):
  364. stmt = stmt[len(u'var '):]
  365. ass_m = re.match(r'^(?P<out>[a-z]+)(?:\[(?P<index>[^\]]+)\])?' +
  366. r'=(?P<expr>.*)$', stmt)
  367. if ass_m:
  368. if ass_m.groupdict().get('index'):
  369. def assign(val):
  370. lvar = local_vars[ass_m.group('out')]
  371. idx = interpret_expression(ass_m.group('index'),
  372. local_vars, allow_recursion)
  373. assert isinstance(idx, int)
  374. lvar[idx] = val
  375. return val
  376. expr = ass_m.group('expr')
  377. else:
  378. def assign(val):
  379. local_vars[ass_m.group('out')] = val
  380. return val
  381. expr = ass_m.group('expr')
  382. elif stmt.startswith(u'return '):
  383. assign = lambda v: v
  384. expr = stmt[len(u'return '):]
  385. else:
  386. raise ExtractorError(
  387. u'Cannot determine left side of statement in %r' % stmt)
  388. v = interpret_expression(expr, local_vars, allow_recursion)
  389. return assign(v)
  390. def interpret_expression(expr, local_vars, allow_recursion):
  391. if expr.isdigit():
  392. return int(expr)
  393. if expr.isalpha():
  394. return local_vars[expr]
  395. m = re.match(r'^(?P<in>[a-z]+)\.(?P<member>.*)$', expr)
  396. if m:
  397. member = m.group('member')
  398. val = local_vars[m.group('in')]
  399. if member == 'split("")':
  400. return list(val)
  401. if member == 'join("")':
  402. return u''.join(val)
  403. if member == 'length':
  404. return len(val)
  405. if member == 'reverse()':
  406. return val[::-1]
  407. slice_m = re.match(r'slice\((?P<idx>.*)\)', member)
  408. if slice_m:
  409. idx = interpret_expression(
  410. slice_m.group('idx'), local_vars, allow_recursion-1)
  411. return val[idx:]
  412. m = re.match(
  413. r'^(?P<in>[a-z]+)\[(?P<idx>.+)\]$', expr)
  414. if m:
  415. val = local_vars[m.group('in')]
  416. idx = interpret_expression(m.group('idx'), local_vars,
  417. allow_recursion-1)
  418. return val[idx]
  419. m = re.match(r'^(?P<a>.+?)(?P<op>[%])(?P<b>.+?)$', expr)
  420. if m:
  421. a = interpret_expression(m.group('a'),
  422. local_vars, allow_recursion)
  423. b = interpret_expression(m.group('b'),
  424. local_vars, allow_recursion)
  425. return a % b
  426. m = re.match(
  427. r'^(?P<func>[a-zA-Z]+)\((?P<args>[a-z0-9,]+)\)$', expr)
  428. if m:
  429. fname = m.group('func')
  430. if fname not in functions:
  431. functions[fname] = extract_function(fname)
  432. argvals = [int(v) if v.isdigit() else local_vars[v]
  433. for v in m.group('args').split(',')]
  434. return functions[fname](argvals)
  435. raise ExtractorError(u'Unsupported JS expression %r' % expr)
  436. def extract_function(funcname):
  437. func_m = re.search(
  438. r'function ' + re.escape(funcname) +
  439. r'\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}',
  440. jscode)
  441. argnames = func_m.group('args').split(',')
  442. def resf(args):
  443. local_vars = dict(zip(argnames, args))
  444. for stmt in func_m.group('code').split(';'):
  445. res = interpret_statement(stmt, local_vars)
  446. return res
  447. return resf
  448. initial_function = extract_function(funcname)
  449. return lambda s: initial_function([s])
  450. def _parse_sig_swf(self, file_contents):
  451. if file_contents[1:3] != b'WS':
  452. raise ExtractorError(
  453. u'Not an SWF file; header is %r' % file_contents[:3])
  454. if file_contents[:1] == b'C':
  455. content = zlib.decompress(file_contents[8:])
  456. else:
  457. raise NotImplementedError(u'Unsupported compression format %r' %
  458. file_contents[:1])
  459. def extract_tags(content):
  460. pos = 0
  461. while pos < len(content):
  462. header16 = struct.unpack('<H', content[pos:pos+2])[0]
  463. pos += 2
  464. tag_code = header16 >> 6
  465. tag_len = header16 & 0x3f
  466. if tag_len == 0x3f:
  467. tag_len = struct.unpack('<I', content[pos:pos+4])[0]
  468. pos += 4
  469. assert pos+tag_len <= len(content)
  470. yield (tag_code, content[pos:pos+tag_len])
  471. pos += tag_len
  472. code_tag = next(tag
  473. for tag_code, tag in extract_tags(content)
  474. if tag_code == 82)
  475. p = code_tag.index(b'\0', 4) + 1
  476. code_reader = io.BytesIO(code_tag[p:])
  477. # Parse ABC (AVM2 ByteCode)
  478. def read_int(reader=None):
  479. if reader is None:
  480. reader = code_reader
  481. res = 0
  482. shift = 0
  483. for _ in range(5):
  484. buf = reader.read(1)
  485. assert len(buf) == 1
  486. b = struct.unpack('<B', buf)[0]
  487. res = res | ((b & 0x7f) << shift)
  488. if b & 0x80 == 0:
  489. break
  490. shift += 7
  491. return res
  492. def u30(reader=None):
  493. res = read_int(reader)
  494. assert res & 0xf0000000 == 0
  495. return res
  496. u32 = read_int
  497. def s32(reader=None):
  498. v = read_int(reader)
  499. if v & 0x80000000 != 0:
  500. v = - ((v ^ 0xffffffff) + 1)
  501. return v
  502. def read_string(reader=None):
  503. if reader is None:
  504. reader = code_reader
  505. slen = u30(reader)
  506. resb = reader.read(slen)
  507. assert len(resb) == slen
  508. return resb.decode('utf-8')
  509. def read_bytes(count, reader=None):
  510. if reader is None:
  511. reader = code_reader
  512. resb = reader.read(count)
  513. assert len(resb) == count
  514. return resb
  515. def read_byte(reader=None):
  516. resb = read_bytes(1, reader=reader)
  517. res = struct.unpack('<B', resb)[0]
  518. return res
  519. # minor_version + major_version
  520. read_bytes(2 + 2)
  521. # Constant pool
  522. int_count = u30()
  523. for _c in range(1, int_count):
  524. s32()
  525. uint_count = u30()
  526. for _c in range(1, uint_count):
  527. u32()
  528. double_count = u30()
  529. read_bytes((double_count-1) * 8)
  530. string_count = u30()
  531. constant_strings = [u'']
  532. for _c in range(1, string_count):
  533. s = read_string()
  534. constant_strings.append(s)
  535. namespace_count = u30()
  536. for _c in range(1, namespace_count):
  537. read_bytes(1) # kind
  538. u30() # name
  539. ns_set_count = u30()
  540. for _c in range(1, ns_set_count):
  541. count = u30()
  542. for _c2 in range(count):
  543. u30()
  544. multiname_count = u30()
  545. MULTINAME_SIZES = {
  546. 0x07: 2, # QName
  547. 0x0d: 2, # QNameA
  548. 0x0f: 1, # RTQName
  549. 0x10: 1, # RTQNameA
  550. 0x11: 0, # RTQNameL
  551. 0x12: 0, # RTQNameLA
  552. 0x09: 2, # Multiname
  553. 0x0e: 2, # MultinameA
  554. 0x1b: 1, # MultinameL
  555. 0x1c: 1, # MultinameLA
  556. }
  557. multinames = [u'']
  558. for _c in range(1, multiname_count):
  559. kind = u30()
  560. assert kind in MULTINAME_SIZES, u'Invalid multiname kind %r' % kind
  561. if kind == 0x07:
  562. u30() # namespace_idx
  563. name_idx = u30()
  564. multinames.append(constant_strings[name_idx])
  565. else:
  566. multinames.append('[MULTINAME kind: %d]' % kind)
  567. for _c2 in range(MULTINAME_SIZES[kind]):
  568. u30()
  569. # Methods
  570. method_count = u30()
  571. MethodInfo = collections.namedtuple(
  572. 'MethodInfo',
  573. ['NEED_ARGUMENTS', 'NEED_REST'])
  574. method_infos = []
  575. for method_id in range(method_count):
  576. param_count = u30()
  577. u30() # return type
  578. for _ in range(param_count):
  579. u30() # param type
  580. u30() # name index (always 0 for youtube)
  581. flags = read_byte()
  582. if flags & 0x08 != 0:
  583. # Options present
  584. option_count = u30()
  585. for c in range(option_count):
  586. u30() # val
  587. read_bytes(1) # kind
  588. if flags & 0x80 != 0:
  589. # Param names present
  590. for _ in range(param_count):
  591. u30() # param name
  592. mi = MethodInfo(flags & 0x01 != 0, flags & 0x04 != 0)
  593. method_infos.append(mi)
  594. # Metadata
  595. metadata_count = u30()
  596. for _c in range(metadata_count):
  597. u30() # name
  598. item_count = u30()
  599. for _c2 in range(item_count):
  600. u30() # key
  601. u30() # value
  602. def parse_traits_info():
  603. trait_name_idx = u30()
  604. kind_full = read_byte()
  605. kind = kind_full & 0x0f
  606. attrs = kind_full >> 4
  607. methods = {}
  608. if kind in [0x00, 0x06]: # Slot or Const
  609. u30() # Slot id
  610. u30() # type_name_idx
  611. vindex = u30()
  612. if vindex != 0:
  613. read_byte() # vkind
  614. elif kind in [0x01, 0x02, 0x03]: # Method / Getter / Setter
  615. u30() # disp_id
  616. method_idx = u30()
  617. methods[multinames[trait_name_idx]] = method_idx
  618. elif kind == 0x04: # Class
  619. u30() # slot_id
  620. u30() # classi
  621. elif kind == 0x05: # Function
  622. u30() # slot_id
  623. function_idx = u30()
  624. methods[function_idx] = multinames[trait_name_idx]
  625. else:
  626. raise ExtractorError(u'Unsupported trait kind %d' % kind)
  627. if attrs & 0x4 != 0: # Metadata present
  628. metadata_count = u30()
  629. for _c3 in range(metadata_count):
  630. u30() # metadata index
  631. return methods
  632. # Classes
  633. TARGET_CLASSNAME = u'SignatureDecipher'
  634. searched_idx = multinames.index(TARGET_CLASSNAME)
  635. searched_class_id = None
  636. class_count = u30()
  637. for class_id in range(class_count):
  638. name_idx = u30()
  639. if name_idx == searched_idx:
  640. # We found the class we're looking for!
  641. searched_class_id = class_id
  642. u30() # super_name idx
  643. flags = read_byte()
  644. if flags & 0x08 != 0: # Protected namespace is present
  645. u30() # protected_ns_idx
  646. intrf_count = u30()
  647. for _c2 in range(intrf_count):
  648. u30()
  649. u30() # iinit
  650. trait_count = u30()
  651. for _c2 in range(trait_count):
  652. parse_traits_info()
  653. if searched_class_id is None:
  654. raise ExtractorError(u'Target class %r not found' %
  655. TARGET_CLASSNAME)
  656. method_names = {}
  657. method_idxs = {}
  658. for class_id in range(class_count):
  659. u30() # cinit
  660. trait_count = u30()
  661. for _c2 in range(trait_count):
  662. trait_methods = parse_traits_info()
  663. if class_id == searched_class_id:
  664. method_names.update(trait_methods.items())
  665. method_idxs.update(dict(
  666. (idx, name)
  667. for name, idx in trait_methods.items()))
  668. # Scripts
  669. script_count = u30()
  670. for _c in range(script_count):
  671. u30() # init
  672. trait_count = u30()
  673. for _c2 in range(trait_count):
  674. parse_traits_info()
  675. # Method bodies
  676. method_body_count = u30()
  677. Method = collections.namedtuple('Method', ['code', 'local_count'])
  678. methods = {}
  679. for _c in range(method_body_count):
  680. method_idx = u30()
  681. u30() # max_stack
  682. local_count = u30()
  683. u30() # init_scope_depth
  684. u30() # max_scope_depth
  685. code_length = u30()
  686. code = read_bytes(code_length)
  687. if method_idx in method_idxs:
  688. m = Method(code, local_count)
  689. methods[method_idxs[method_idx]] = m
  690. exception_count = u30()
  691. for _c2 in range(exception_count):
  692. u30() # from
  693. u30() # to
  694. u30() # target
  695. u30() # exc_type
  696. u30() # var_name
  697. trait_count = u30()
  698. for _c2 in range(trait_count):
  699. parse_traits_info()
  700. assert p + code_reader.tell() == len(code_tag)
  701. assert len(methods) == len(method_idxs)
  702. method_pyfunctions = {}
  703. def extract_function(func_name):
  704. if func_name in method_pyfunctions:
  705. return method_pyfunctions[func_name]
  706. if func_name not in methods:
  707. raise ExtractorError(u'Cannot find function %r' % func_name)
  708. m = methods[func_name]
  709. def resfunc(args):
  710. registers = ['(this)'] + list(args) + [None] * m.local_count
  711. stack = []
  712. coder = io.BytesIO(m.code)
  713. while True:
  714. opcode = struct.unpack('!B', coder.read(1))[0]
  715. if opcode == 36: # pushbyte
  716. v = struct.unpack('!B', coder.read(1))[0]
  717. stack.append(v)
  718. elif opcode == 44: # pushstring
  719. idx = u30(coder)
  720. stack.append(constant_strings[idx])
  721. elif opcode == 48: # pushscope
  722. # We don't implement the scope register, so we'll just
  723. # ignore the popped value
  724. stack.pop()
  725. elif opcode == 70: # callproperty
  726. index = u30(coder)
  727. mname = multinames[index]
  728. arg_count = u30(coder)
  729. args = list(reversed(
  730. [stack.pop() for _ in range(arg_count)]))
  731. obj = stack.pop()
  732. if mname == u'split':
  733. assert len(args) == 1
  734. assert isinstance(args[0], compat_str)
  735. assert isinstance(obj, compat_str)
  736. if args[0] == u'':
  737. res = list(obj)
  738. else:
  739. res = obj.split(args[0])
  740. stack.append(res)
  741. elif mname == u'slice':
  742. assert len(args) == 1
  743. assert isinstance(args[0], int)
  744. assert isinstance(obj, list)
  745. res = obj[args[0]:]
  746. stack.append(res)
  747. elif mname == u'join':
  748. assert len(args) == 1
  749. assert isinstance(args[0], compat_str)
  750. assert isinstance(obj, list)
  751. res = args[0].join(obj)
  752. stack.append(res)
  753. elif mname in method_pyfunctions:
  754. stack.append(method_pyfunctions[mname](args))
  755. else:
  756. raise NotImplementedError(
  757. u'Unsupported property %r on %r'
  758. % (mname, obj))
  759. elif opcode == 72: # returnvalue
  760. res = stack.pop()
  761. return res
  762. elif opcode == 79: # callpropvoid
  763. index = u30(coder)
  764. mname = multinames[index]
  765. arg_count = u30(coder)
  766. args = list(reversed(
  767. [stack.pop() for _ in range(arg_count)]))
  768. obj = stack.pop()
  769. if mname == u'reverse':
  770. assert isinstance(obj, list)
  771. obj.reverse()
  772. else:
  773. raise NotImplementedError(
  774. u'Unsupported (void) property %r on %r'
  775. % (mname, obj))
  776. elif opcode == 93: # findpropstrict
  777. index = u30(coder)
  778. mname = multinames[index]
  779. res = extract_function(mname)
  780. stack.append(res)
  781. elif opcode == 97: # setproperty
  782. index = u30(coder)
  783. value = stack.pop()
  784. idx = stack.pop()
  785. obj = stack.pop()
  786. assert isinstance(obj, list)
  787. assert isinstance(idx, int)
  788. obj[idx] = value
  789. elif opcode == 98: # getlocal
  790. index = u30(coder)
  791. stack.append(registers[index])
  792. elif opcode == 99: # setlocal
  793. index = u30(coder)
  794. value = stack.pop()
  795. registers[index] = value
  796. elif opcode == 102: # getproperty
  797. index = u30(coder)
  798. pname = multinames[index]
  799. if pname == u'length':
  800. obj = stack.pop()
  801. assert isinstance(obj, list)
  802. stack.append(len(obj))
  803. else: # Assume attribute access
  804. idx = stack.pop()
  805. assert isinstance(idx, int)
  806. obj = stack.pop()
  807. assert isinstance(obj, list)
  808. stack.append(obj[idx])
  809. elif opcode == 128: # coerce
  810. u30(coder)
  811. elif opcode == 133: # coerce_s
  812. assert isinstance(stack[-1], (type(None), compat_str))
  813. elif opcode == 164: # modulo
  814. value2 = stack.pop()
  815. value1 = stack.pop()
  816. res = value1 % value2
  817. stack.append(res)
  818. elif opcode == 208: # getlocal_0
  819. stack.append(registers[0])
  820. elif opcode == 209: # getlocal_1
  821. stack.append(registers[1])
  822. elif opcode == 210: # getlocal_2
  823. stack.append(registers[2])
  824. elif opcode == 211: # getlocal_3
  825. stack.append(registers[3])
  826. elif opcode == 214: # setlocal_2
  827. registers[2] = stack.pop()
  828. elif opcode == 215: # setlocal_3
  829. registers[3] = stack.pop()
  830. else:
  831. raise NotImplementedError(
  832. u'Unsupported opcode %d' % opcode)
  833. method_pyfunctions[func_name] = resfunc
  834. return resfunc
  835. initial_function = extract_function(u'decipher')
  836. return lambda s: initial_function([s])
  837. def _decrypt_signature(self, s, video_id, player_url, age_gate=False):
  838. """Turn the encrypted s field into a working signature"""
  839. if player_url is not None:
  840. if player_url.startswith(u'//'):
  841. player_url = u'https:' + player_url
  842. try:
  843. player_id = (player_url, len(s))
  844. if player_id not in self._player_cache:
  845. func = self._extract_signature_function(
  846. video_id, player_url, len(s)
  847. )
  848. self._player_cache[player_id] = func
  849. func = self._player_cache[player_id]
  850. if self._downloader.params.get('youtube_print_sig_code'):
  851. self._print_sig_code(func, len(s))
  852. return func(s)
  853. except Exception:
  854. tb = traceback.format_exc()
  855. self._downloader.report_warning(
  856. u'Automatic signature extraction failed: ' + tb)
  857. self._downloader.report_warning(
  858. u'Warning: Falling back to static signature algorithm')
  859. return self._static_decrypt_signature(
  860. s, video_id, player_url, age_gate)
  861. def _static_decrypt_signature(self, s, video_id, player_url, age_gate):
  862. if age_gate:
  863. # The videos with age protection use another player, so the
  864. # algorithms can be different.
  865. if len(s) == 86:
  866. return s[2:63] + s[82] + s[64:82] + s[63]
  867. if len(s) == 93:
  868. return s[86:29:-1] + s[88] + s[28:5:-1]
  869. elif len(s) == 92:
  870. return s[25] + s[3:25] + s[0] + s[26:42] + s[79] + s[43:79] + s[91] + s[80:83]
  871. elif len(s) == 91:
  872. return s[84:27:-1] + s[86] + s[26:5:-1]
  873. elif len(s) == 90:
  874. return s[25] + s[3:25] + s[2] + s[26:40] + s[77] + s[41:77] + s[89] + s[78:81]
  875. elif len(s) == 89:
  876. return s[84:78:-1] + s[87] + s[77:60:-1] + s[0] + s[59:3:-1]
  877. elif len(s) == 88:
  878. return s[7:28] + s[87] + s[29:45] + s[55] + s[46:55] + s[2] + s[56:87] + s[28]
  879. elif len(s) == 87:
  880. return s[6:27] + s[4] + s[28:39] + s[27] + s[40:59] + s[2] + s[60:]
  881. elif len(s) == 86:
  882. return s[80:72:-1] + s[16] + s[71:39:-1] + s[72] + s[38:16:-1] + s[82] + s[15::-1]
  883. elif len(s) == 85:
  884. return s[3:11] + s[0] + s[12:55] + s[84] + s[56:84]
  885. elif len(s) == 84:
  886. return s[78:70:-1] + s[14] + s[69:37:-1] + s[70] + s[36:14:-1] + s[80] + s[:14][::-1]
  887. elif len(s) == 83:
  888. return s[80:63:-1] + s[0] + s[62:0:-1] + s[63]
  889. elif len(s) == 82:
  890. return s[80:37:-1] + s[7] + s[36:7:-1] + s[0] + s[6:0:-1] + s[37]
  891. elif len(s) == 81:
  892. return s[56] + s[79:56:-1] + s[41] + s[55:41:-1] + s[80] + s[40:34:-1] + s[0] + s[33:29:-1] + s[34] + s[28:9:-1] + s[29] + s[8:0:-1] + s[9]
  893. elif len(s) == 80:
  894. return s[1:19] + s[0] + s[20:68] + s[19] + s[69:80]
  895. elif len(s) == 79:
  896. return s[54] + s[77:54:-1] + s[39] + s[53:39:-1] + s[78] + s[38:34:-1] + s[0] + s[33:29:-1] + s[34] + s[28:9:-1] + s[29] + s[8:0:-1] + s[9]
  897. else:
  898. raise ExtractorError(u'Unable to decrypt signature, key length %d not supported; retrying might work' % (len(s)))
  899. def _get_available_subtitles(self, video_id, webpage):
  900. try:
  901. sub_list = self._download_webpage(
  902. 'http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id,
  903. video_id, note=False)
  904. except ExtractorError as err:
  905. self._downloader.report_warning(u'unable to download video subtitles: %s' % compat_str(err))
  906. return {}
  907. lang_list = re.findall(r'name="([^"]*)"[^>]+lang_code="([\w\-]+)"', sub_list)
  908. sub_lang_list = {}
  909. for l in lang_list:
  910. lang = l[1]
  911. params = compat_urllib_parse.urlencode({
  912. 'lang': lang,
  913. 'v': video_id,
  914. 'fmt': self._downloader.params.get('subtitlesformat', 'srt'),
  915. 'name': unescapeHTML(l[0]).encode('utf-8'),
  916. })
  917. url = u'http://www.youtube.com/api/timedtext?' + params
  918. sub_lang_list[lang] = url
  919. if not sub_lang_list:
  920. self._downloader.report_warning(u'video doesn\'t have subtitles')
  921. return {}
  922. return sub_lang_list
  923. def _get_available_automatic_caption(self, video_id, webpage):
  924. """We need the webpage for getting the captions url, pass it as an
  925. argument to speed up the process."""
  926. sub_format = self._downloader.params.get('subtitlesformat', 'srt')
  927. self.to_screen(u'%s: Looking for automatic captions' % video_id)
  928. mobj = re.search(r';ytplayer.config = ({.*?});', webpage)
  929. err_msg = u'Couldn\'t find automatic captions for %s' % video_id
  930. if mobj is None:
  931. self._downloader.report_warning(err_msg)
  932. return {}
  933. player_config = json.loads(mobj.group(1))
  934. try:
  935. args = player_config[u'args']
  936. caption_url = args[u'ttsurl']
  937. timestamp = args[u'timestamp']
  938. # We get the available subtitles
  939. list_params = compat_urllib_parse.urlencode({
  940. 'type': 'list',
  941. 'tlangs': 1,
  942. 'asrs': 1,
  943. })
  944. list_url = caption_url + '&' + list_params
  945. caption_list = self._download_xml(list_url, video_id)
  946. original_lang_node = caption_list.find('track')
  947. if original_lang_node is None or original_lang_node.attrib.get('kind') != 'asr' :
  948. self._downloader.report_warning(u'Video doesn\'t have automatic captions')
  949. return {}
  950. original_lang = original_lang_node.attrib['lang_code']
  951. sub_lang_list = {}
  952. for lang_node in caption_list.findall('target'):
  953. sub_lang = lang_node.attrib['lang_code']
  954. params = compat_urllib_parse.urlencode({
  955. 'lang': original_lang,
  956. 'tlang': sub_lang,
  957. 'fmt': sub_format,
  958. 'ts': timestamp,
  959. 'kind': 'asr',
  960. })
  961. sub_lang_list[sub_lang] = caption_url + '&' + params
  962. return sub_lang_list
  963. # An extractor error can be raise by the download process if there are
  964. # no automatic captions but there are subtitles
  965. except (KeyError, ExtractorError):
  966. self._downloader.report_warning(err_msg)
  967. return {}
  968. def _extract_id(self, url):
  969. mobj = re.match(self._VALID_URL, url, re.VERBOSE)
  970. if mobj is None:
  971. raise ExtractorError(u'Invalid URL: %s' % url)
  972. video_id = mobj.group(2)
  973. return video_id
  974. def _get_video_url_list(self, url_map):
  975. """
  976. Transform a dictionary in the format {itag:url} to a list of (itag, url)
  977. with the requested formats.
  978. """
  979. existing_formats = [x for x in self._formats if x in url_map]
  980. if len(existing_formats) == 0:
  981. raise ExtractorError(u'no known formats available for video')
  982. video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats
  983. video_url_list.reverse() # order worst to best
  984. return video_url_list
  985. def _extract_from_m3u8(self, manifest_url, video_id):
  986. url_map = {}
  987. def _get_urls(_manifest):
  988. lines = _manifest.split('\n')
  989. urls = filter(lambda l: l and not l.startswith('#'),
  990. lines)
  991. return urls
  992. manifest = self._download_webpage(manifest_url, video_id, u'Downloading formats manifest')
  993. formats_urls = _get_urls(manifest)
  994. for format_url in formats_urls:
  995. itag = self._search_regex(r'itag/(\d+?)/', format_url, 'itag')
  996. url_map[itag] = format_url
  997. return url_map
  998. def _extract_annotations(self, video_id):
  999. url = 'https://www.youtube.com/annotations_invideo?features=1&legacy=1&video_id=%s' % video_id
  1000. return self._download_webpage(url, video_id, note=u'Searching for annotations.', errnote=u'Unable to download video annotations.')
  1001. def _real_extract(self, url):
  1002. # Extract original video URL from URL with redirection, like age verification, using next_url parameter
  1003. mobj = re.search(self._NEXT_URL_RE, url)
  1004. if mobj:
  1005. url = 'https://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
  1006. video_id = self._extract_id(url)
  1007. # Get video webpage
  1008. url = 'https://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1' % video_id
  1009. video_webpage = self._download_webpage(url, video_id)
  1010. # Attempt to extract SWF player URL
  1011. mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
  1012. if mobj is not None:
  1013. player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
  1014. else:
  1015. player_url = None
  1016. # Get video info
  1017. self.report_video_info_webpage_download(video_id)
  1018. if re.search(r'player-age-gate-content">', video_webpage) is not None:
  1019. self.report_age_confirmation()
  1020. age_gate = True
  1021. # We simulate the access to the video from www.youtube.com/v/{video_id}
  1022. # this can be viewed without login into Youtube
  1023. data = compat_urllib_parse.urlencode({'video_id': video_id,
  1024. 'el': 'player_embedded',
  1025. 'gl': 'US',
  1026. 'hl': 'en',
  1027. 'eurl': 'https://youtube.googleapis.com/v/' + video_id,
  1028. 'asv': 3,
  1029. 'sts':'1588',
  1030. })
  1031. video_info_url = 'https://www.youtube.com/get_video_info?' + data
  1032. video_info_webpage = self._download_webpage(video_info_url, video_id,
  1033. note=False,
  1034. errnote='unable to download video info webpage')
  1035. video_info = compat_parse_qs(video_info_webpage)
  1036. else:
  1037. age_gate = False
  1038. for el_type in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
  1039. video_info_url = ('https://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
  1040. % (video_id, el_type))
  1041. video_info_webpage = self._download_webpage(video_info_url, video_id,
  1042. note=False,
  1043. errnote='unable to download video info webpage')
  1044. video_info = compat_parse_qs(video_info_webpage)
  1045. if 'token' in video_info:
  1046. break
  1047. if 'token' not in video_info:
  1048. if 'reason' in video_info:
  1049. raise ExtractorError(u'YouTube said: %s' % video_info['reason'][0], expected=True)
  1050. else:
  1051. raise ExtractorError(u'"token" parameter not in video info for unknown reason')
  1052. if 'view_count' in video_info:
  1053. view_count = int(video_info['view_count'][0])
  1054. else:
  1055. view_count = None
  1056. # Check for "rental" videos
  1057. if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
  1058. raise ExtractorError(u'"rental" videos not supported')
  1059. # Start extracting information
  1060. self.report_information_extraction(video_id)
  1061. # uploader
  1062. if 'author' not in video_info:
  1063. raise ExtractorError(u'Unable to extract uploader name')
  1064. video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
  1065. # uploader_id
  1066. video_uploader_id = None
  1067. mobj = re.search(r'<link itemprop="url" href="http://www.youtube.com/(?:user|channel)/([^"]+)">', video_webpage)
  1068. if mobj is not None:
  1069. video_uploader_id = mobj.group(1)
  1070. else:
  1071. self._downloader.report_warning(u'unable to extract uploader nickname')
  1072. # title
  1073. if 'title' in video_info:
  1074. video_title = compat_urllib_parse.unquote_plus(video_info['title'][0])
  1075. else:
  1076. self._downloader.report_warning(u'Unable to extract video title')
  1077. video_title = u'_'
  1078. # thumbnail image
  1079. # We try first to get a high quality image:
  1080. m_thumb = re.search(r'<span itemprop="thumbnail".*?href="(.*?)">',
  1081. video_webpage, re.DOTALL)
  1082. if m_thumb is not None:
  1083. video_thumbnail = m_thumb.group(1)
  1084. elif 'thumbnail_url' not in video_info:
  1085. self._downloader.report_warning(u'unable to extract video thumbnail')
  1086. video_thumbnail = None
  1087. else: # don't panic if we can't find it
  1088. video_thumbnail = compat_urllib_parse.unquote_plus(video_info['thumbnail_url'][0])
  1089. # upload date
  1090. upload_date = None
  1091. mobj = re.search(r'id="eow-date.*?>(.*?)</span>', video_webpage, re.DOTALL)
  1092. if mobj is not None:
  1093. upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
  1094. upload_date = unified_strdate(upload_date)
  1095. # description
  1096. video_description = get_element_by_id("eow-description", video_webpage)
  1097. if video_description:
  1098. video_description = re.sub(r'''(?x)
  1099. <a\s+
  1100. (?:[a-zA-Z-]+="[^"]+"\s+)*?
  1101. title="([^"]+)"\s+
  1102. (?:[a-zA-Z-]+="[^"]+"\s+)*?
  1103. class="yt-uix-redirect-link"\s*>
  1104. [^<]+
  1105. </a>
  1106. ''', r'\1', video_description)
  1107. video_description = clean_html(video_description)
  1108. else:
  1109. fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
  1110. if fd_mobj:
  1111. video_description = unescapeHTML(fd_mobj.group(1))
  1112. else:
  1113. video_description = u''
  1114. def _extract_count(klass):
  1115. count = self._search_regex(
  1116. r'class="%s">([\d,]+)</span>' % re.escape(klass),
  1117. video_webpage, klass, default=None)
  1118. if count is not None:
  1119. return int(count.replace(',', ''))
  1120. return None
  1121. like_count = _extract_count(u'likes-count')
  1122. dislike_count = _extract_count(u'dislikes-count')
  1123. # subtitles
  1124. video_subtitles = self.extract_subtitles(video_id, video_webpage)
  1125. if self._downloader.params.get('listsubtitles', False):
  1126. self._list_available_subtitles(video_id, video_webpage)
  1127. return
  1128. if 'length_seconds' not in video_info:
  1129. self._downloader.report_warning(u'unable to extract video duration')
  1130. video_duration = None
  1131. else:
  1132. video_duration = int(compat_urllib_parse.unquote_plus(video_info['length_seconds'][0]))
  1133. # annotations
  1134. video_annotations = None
  1135. if self._downloader.params.get('writeannotations', False):
  1136. video_annotations = self._extract_annotations(video_id)
  1137. # Decide which formats to download
  1138. try:
  1139. mobj = re.search(r';ytplayer.config = ({.*?});', video_webpage)
  1140. if not mobj:
  1141. raise ValueError('Could not find vevo ID')
  1142. info = json.loads(mobj.group(1))
  1143. args = info['args']
  1144. # Easy way to know if the 's' value is in url_encoded_fmt_stream_map
  1145. # this signatures are encrypted
  1146. if 'url_encoded_fmt_stream_map' not in args:
  1147. raise ValueError(u'No stream_map present') # caught below
  1148. re_signature = re.compile(r'[&,]s=')
  1149. m_s = re_signature.search(args['url_encoded_fmt_stream_map'])
  1150. if m_s is not None:
  1151. self.to_screen(u'%s: Encrypted signatures detected.' % video_id)
  1152. video_info['url_encoded_fmt_stream_map'] = [args['url_encoded_fmt_stream_map']]
  1153. m_s = re_signature.search(args.get('adaptive_fmts', u''))
  1154. if m_s is not None:
  1155. if 'adaptive_fmts' in video_info:
  1156. video_info['adaptive_fmts'][0] += ',' + args['adaptive_fmts']
  1157. else:
  1158. video_info['adaptive_fmts'] = [args['adaptive_fmts']]
  1159. except ValueError:
  1160. pass
  1161. if 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
  1162. self.report_rtmp_download()
  1163. video_url_list = [('_rtmp', video_info['conn'][0])]
  1164. elif len(video_info.get('url_encoded_fmt_stream_map', [])) >= 1 or len(video_info.get('adaptive_fmts', [])) >= 1:
  1165. encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + ',' + video_info.get('adaptive_fmts',[''])[0]
  1166. if 'rtmpe%3Dyes' in encoded_url_map:
  1167. raise ExtractorError('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343 for more information.', expected=True)
  1168. url_map = {}
  1169. for url_data_str in encoded_url_map.split(','):
  1170. url_data = compat_parse_qs(url_data_str)
  1171. if 'itag' in url_data and 'url' in url_data:
  1172. url = url_data['url'][0]
  1173. if 'sig' in url_data:
  1174. url += '&signature=' + url_data['sig'][0]
  1175. elif 's' in url_data:
  1176. encrypted_sig = url_data['s'][0]
  1177. if self._downloader.params.get('verbose'):
  1178. if age_gate:
  1179. if player_url is None:
  1180. player_version = 'unknown'
  1181. else:
  1182. player_version = self._search_regex(
  1183. r'-(.+)\.swf$', player_url,
  1184. u'flash player', fatal=False)
  1185. player_desc = 'flash player %s' % player_version
  1186. else:
  1187. player_version = self._search_regex(
  1188. r'html5player-(.+?)\.js', video_webpage,
  1189. 'html5 player', fatal=False)
  1190. player_desc = u'html5 player %s' % player_version
  1191. parts_sizes = u'.'.join(compat_str(len(part)) for part in encrypted_sig.split('.'))
  1192. self.to_screen(u'encrypted signature length %d (%s), itag %s, %s' %
  1193. (len(encrypted_sig), parts_sizes, url_data['itag'][0], player_desc))
  1194. if not age_gate:
  1195. jsplayer_url_json = self._search_regex(
  1196. r'"assets":.+?"js":\s*("[^"]+")',
  1197. video_webpage, u'JS player URL')
  1198. player_url = json.loads(jsplayer_url_json)
  1199. signature = self._decrypt_signature(
  1200. encrypted_sig, video_id, player_url, age_gate)
  1201. url += '&signature=' + signature
  1202. if 'ratebypass' not in url:
  1203. url += '&ratebypass=yes'
  1204. url_map[url_data['itag'][0]] = url
  1205. video_url_list = self._get_video_url_list(url_map)
  1206. elif video_info.get('hlsvp'):
  1207. manifest_url = video_info['hlsvp'][0]
  1208. url_map = self._extract_from_m3u8(manifest_url, video_id)
  1209. video_url_list = self._get_video_url_list(url_map)
  1210. else:
  1211. raise ExtractorError(u'no conn, hlsvp or url_encoded_fmt_stream_map information found in video info')
  1212. formats = []
  1213. for itag, video_real_url in video_url_list:
  1214. dct = {
  1215. 'format_id': itag,
  1216. 'url': video_real_url,
  1217. 'player_url': player_url,
  1218. }
  1219. dct.update(self._formats[itag])
  1220. formats.append(dct)
  1221. self._sort_formats(formats)
  1222. return {
  1223. 'id': video_id,
  1224. 'uploader': video_uploader,
  1225. 'uploader_id': video_uploader_id,
  1226. 'upload_date': upload_date,
  1227. 'title': video_title,
  1228. 'thumbnail': video_thumbnail,
  1229. 'description': video_description,
  1230. 'subtitles': video_subtitles,
  1231. 'duration': video_duration,
  1232. 'age_limit': 18 if age_gate else 0,
  1233. 'annotations': video_annotations,
  1234. 'webpage_url': 'https://www.youtube.com/watch?v=%s' % video_id,
  1235. 'view_count': view_count,
  1236. 'like_count': like_count,
  1237. 'dislike_count': dislike_count,
  1238. 'formats': formats,
  1239. }
  1240. class YoutubePlaylistIE(YoutubeBaseInfoExtractor):
  1241. IE_DESC = u'YouTube.com playlists'
  1242. _VALID_URL = r"""(?:
  1243. (?:https?://)?
  1244. (?:\w+\.)?
  1245. youtube\.com/
  1246. (?:
  1247. (?:course|view_play_list|my_playlists|artist|playlist|watch)
  1248. \? (?:.*?&)*? (?:p|a|list)=
  1249. | p/
  1250. )
  1251. ((?:PL|EC|UU|FL|RD)?[0-9A-Za-z-_]{10,})
  1252. .*
  1253. |
  1254. ((?:PL|EC|UU|FL|RD)[0-9A-Za-z-_]{10,})
  1255. )"""
  1256. _TEMPLATE_URL = 'https://www.youtube.com/playlist?list=%s&page=%s'
  1257. _MORE_PAGES_INDICATOR = r'data-link-type="next"'
  1258. _VIDEO_RE = r'href="/watch\?v=(?P<id>[0-9A-Za-z_-]{11})&amp;[^"]*?index=(?P<index>\d+)'
  1259. IE_NAME = u'youtube:playlist'
  1260. @classmethod
  1261. def suitable(cls, url):
  1262. """Receives a URL and returns True if suitable for this IE."""
  1263. return re.match(cls._VALID_URL, url, re.VERBOSE) is not None
  1264. def _real_initialize(self):
  1265. self._login()
  1266. def _ids_to_results(self, ids):
  1267. return [self.url_result(vid_id, 'Youtube', video_id=vid_id)
  1268. for vid_id in ids]
  1269. def _extract_mix(self, playlist_id):
  1270. # The mixes are generated from a a single video
  1271. # the id of the playlist is just 'RD' + video_id
  1272. url = 'https://youtube.com/watch?v=%s&list=%s' % (playlist_id[-11:], playlist_id)
  1273. webpage = self._download_webpage(url, playlist_id, u'Downloading Youtube mix')
  1274. title_span = (get_element_by_attribute('class', 'title long-title', webpage) or
  1275. get_element_by_attribute('class', 'title ', webpage))
  1276. title = clean_html(title_span)
  1277. video_re = r'data-index="\d+".*?href="/watch\?v=([0-9A-Za-z_-]{11})&amp;[^"]*?list=%s' % re.escape(playlist_id)
  1278. ids = orderedSet(re.findall(video_re, webpage))
  1279. url_results = self._ids_to_results(ids)
  1280. return self.playlist_result(url_results, playlist_id, title)
  1281. def _real_extract(self, url):
  1282. # Extract playlist id
  1283. mobj = re.match(self._VALID_URL, url, re.VERBOSE)
  1284. if mobj is None:
  1285. raise ExtractorError(u'Invalid URL: %s' % url)
  1286. playlist_id = mobj.group(1) or mobj.group(2)
  1287. # Check if it's a video-specific URL
  1288. query_dict = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
  1289. if 'v' in query_dict:
  1290. video_id = query_dict['v'][0]
  1291. if self._downloader.params.get('noplaylist'):
  1292. self.to_screen(u'Downloading just video %s because of --no-playlist' % video_id)
  1293. return self.url_result(video_id, 'Youtube', video_id=video_id)
  1294. else:
  1295. self.to_screen(u'Downloading playlist PL%s - add --no-playlist to just download video %s' % (playlist_id, video_id))
  1296. if playlist_id.startswith('RD'):
  1297. # Mixes require a custom extraction process
  1298. return self._extract_mix(playlist_id)
  1299. if playlist_id.startswith('TL'):
  1300. raise ExtractorError(u'For downloading YouTube.com top lists, use '
  1301. u'the "yttoplist" keyword, for example "youtube-dl \'yttoplist:music:Top Tracks\'"', expected=True)
  1302. # Extract the video ids from the playlist pages
  1303. ids = []
  1304. for page_num in itertools.count(1):
  1305. url = self._TEMPLATE_URL % (playlist_id, page_num)
  1306. page = self._download_webpage(url, playlist_id, u'Downloading page #%s' % page_num)
  1307. matches = re.finditer(self._VIDEO_RE, page)
  1308. # We remove the duplicates and the link with index 0
  1309. # (it's not the first video of the playlist)
  1310. new_ids = orderedSet(m.group('id') for m in matches if m.group('index') != '0')
  1311. ids.extend(new_ids)
  1312. if re.search(self._MORE_PAGES_INDICATOR, page) is None:
  1313. break
  1314. playlist_title = self._og_search_title(page)
  1315. url_results = self._ids_to_results(ids)
  1316. return self.playlist_result(url_results, playlist_id, playlist_title)
  1317. class YoutubeTopListIE(YoutubePlaylistIE):
  1318. IE_NAME = u'youtube:toplist'
  1319. IE_DESC = (u'YouTube.com top lists, "yttoplist:{channel}:{list title}"'
  1320. u' (Example: "yttoplist:music:Top Tracks")')
  1321. _VALID_URL = r'yttoplist:(?P<chann>.*?):(?P<title>.*?)$'
  1322. def _real_extract(self, url):
  1323. mobj = re.match(self._VALID_URL, url)
  1324. channel = mobj.group('chann')
  1325. title = mobj.group('title')
  1326. query = compat_urllib_parse.urlencode({'title': title})
  1327. playlist_re = 'href="([^"]+?%s[^"]+?)"' % re.escape(query)
  1328. channel_page = self._download_webpage('https://www.youtube.com/%s' % channel, title)
  1329. link = self._html_search_regex(playlist_re, channel_page, u'list')
  1330. url = compat_urlparse.urljoin('https://www.youtube.com/', link)
  1331. video_re = r'data-index="\d+".*?data-video-id="([0-9A-Za-z_-]{11})"'
  1332. ids = []
  1333. # sometimes the webpage doesn't contain the videos
  1334. # retry until we get them
  1335. for i in itertools.count(0):
  1336. msg = u'Downloading Youtube mix'
  1337. if i > 0:
  1338. msg += ', retry #%d' % i
  1339. webpage = self._download_webpage(url, title, msg)
  1340. ids = orderedSet(re.findall(video_re, webpage))
  1341. if ids:
  1342. break
  1343. url_results = self._ids_to_results(ids)
  1344. return self.playlist_result(url_results, playlist_title=title)
  1345. class YoutubeChannelIE(InfoExtractor):
  1346. IE_DESC = u'YouTube.com channels'
  1347. _VALID_URL = r"^(?:https?://)?(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/([0-9A-Za-z_-]+)"
  1348. _MORE_PAGES_INDICATOR = 'yt-uix-load-more'
  1349. _MORE_PAGES_URL = 'http://www.youtube.com/c4_browse_ajax?action_load_more_videos=1&flow=list&paging=%s&view=0&sort=da&channel_id=%s'
  1350. IE_NAME = u'youtube:channel'
  1351. def extract_videos_from_page(self, page):
  1352. ids_in_page = []
  1353. for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&?', page):
  1354. if mobj.group(1) not in ids_in_page:
  1355. ids_in_page.append(mobj.group(1))
  1356. return ids_in_page
  1357. def _real_extract(self, url):
  1358. # Extract channel id
  1359. mobj = re.match(self._VALID_URL, url)
  1360. if mobj is None:
  1361. raise ExtractorError(u'Invalid URL: %s' % url)
  1362. # Download channel page
  1363. channel_id = mobj.group(1)
  1364. video_ids = []
  1365. url = 'https://www.youtube.com/channel/%s/videos' % channel_id
  1366. channel_page = self._download_webpage(url, channel_id)
  1367. autogenerated = re.search(r'''(?x)
  1368. class="[^"]*?(?:
  1369. channel-header-autogenerated-label|
  1370. yt-channel-title-autogenerated
  1371. )[^"]*"''', channel_page) is not None
  1372. if autogenerated:
  1373. # The videos are contained in a single page
  1374. # the ajax pages can't be used, they are empty
  1375. video_ids = self.extract_videos_from_page(channel_page)
  1376. else:
  1377. # Download all channel pages using the json-based channel_ajax query
  1378. for pagenum in itertools.count(1):
  1379. url = self._MORE_PAGES_URL % (pagenum, channel_id)
  1380. page = self._download_webpage(url, channel_id,
  1381. u'Downloading page #%s' % pagenum)
  1382. page = json.loads(page)
  1383. ids_in_page = self.extract_videos_from_page(page['content_html'])
  1384. video_ids.extend(ids_in_page)
  1385. if self._MORE_PAGES_INDICATOR not in page['load_more_widget_html']:
  1386. break
  1387. self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
  1388. url_entries = [self.url_result(video_id, 'Youtube', video_id=video_id)
  1389. for video_id in video_ids]
  1390. return self.playlist_result(url_entries, channel_id)
  1391. class YoutubeUserIE(InfoExtractor):
  1392. IE_DESC = u'YouTube.com user videos (URL or "ytuser" keyword)'
  1393. _VALID_URL = r'(?:(?:(?:https?://)?(?:\w+\.)?youtube\.com/(?:user/)?(?!(?:attribution_link|watch)(?:$|[^a-z_A-Z0-9-])))|ytuser:)(?!feed/)([A-Za-z0-9_-]+)'
  1394. _TEMPLATE_URL = 'http://gdata.youtube.com/feeds/api/users/%s'
  1395. _GDATA_PAGE_SIZE = 50
  1396. _GDATA_URL = 'http://gdata.youtube.com/feeds/api/users/%s/uploads?max-results=%d&start-index=%d&alt=json'
  1397. IE_NAME = u'youtube:user'
  1398. @classmethod
  1399. def suitable(cls, url):
  1400. # Don't return True if the url can be extracted with other youtube
  1401. # extractor, the regex would is too permissive and it would match.
  1402. other_ies = iter(klass for (name, klass) in globals().items() if name.endswith('IE') and klass is not cls)
  1403. if any(ie.suitable(url) for ie in other_ies): return False
  1404. else: return super(YoutubeUserIE, cls).suitable(url)
  1405. def _real_extract(self, url):
  1406. # Extract username
  1407. mobj = re.match(self._VALID_URL, url)
  1408. if mobj is None:
  1409. raise ExtractorError(u'Invalid URL: %s' % url)
  1410. username = mobj.group(1)
  1411. # Download video ids using YouTube Data API. Result size per
  1412. # query is limited (currently to 50 videos) so we need to query
  1413. # page by page until there are no video ids - it means we got
  1414. # all of them.
  1415. url_results = []
  1416. for pagenum in itertools.count(0):
  1417. start_index = pagenum * self._GDATA_PAGE_SIZE + 1
  1418. gdata_url = self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index)
  1419. page = self._download_webpage(gdata_url, username,
  1420. u'Downloading video ids from %d to %d' % (start_index, start_index + self._GDATA_PAGE_SIZE))
  1421. try:
  1422. response = json.loads(page)
  1423. except ValueError as err:
  1424. raise ExtractorError(u'Invalid JSON in API response: ' + compat_str(err))
  1425. if 'entry' not in response['feed']:
  1426. # Number of videos is a multiple of self._MAX_RESULTS
  1427. break
  1428. # Extract video identifiers
  1429. entries = response['feed']['entry']
  1430. for entry in entries:
  1431. title = entry['title']['$t']
  1432. video_id = entry['id']['$t'].split('/')[-1]
  1433. url_results.append({
  1434. '_type': 'url',
  1435. 'url': video_id,
  1436. 'ie_key': 'Youtube',
  1437. 'id': 'video_id',
  1438. 'title': title,
  1439. })
  1440. # A little optimization - if current page is not
  1441. # "full", ie. does not contain PAGE_SIZE video ids then
  1442. # we can assume that this page is the last one - there
  1443. # are no more ids on further pages - no need to query
  1444. # again.
  1445. if len(entries) < self._GDATA_PAGE_SIZE:
  1446. break
  1447. return self.playlist_result(url_results, playlist_title=username)
  1448. class YoutubeSearchIE(SearchInfoExtractor):
  1449. IE_DESC = u'YouTube.com searches'
  1450. _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc'
  1451. _MAX_RESULTS = 1000
  1452. IE_NAME = u'youtube:search'
  1453. _SEARCH_KEY = 'ytsearch'
  1454. def _get_n_results(self, query, n):
  1455. """Get a specified number of results for a query"""
  1456. video_ids = []
  1457. pagenum = 0
  1458. limit = n
  1459. while (50 * pagenum) < limit:
  1460. result_url = self._API_URL % (compat_urllib_parse.quote_plus(query), (50*pagenum)+1)
  1461. data_json = self._download_webpage(
  1462. result_url, video_id=u'query "%s"' % query,
  1463. note=u'Downloading page %s' % (pagenum + 1),
  1464. errnote=u'Unable to download API page')
  1465. data = json.loads(data_json)
  1466. api_response = data['data']
  1467. if 'items' not in api_response:
  1468. raise ExtractorError(u'[youtube] No video results')
  1469. new_ids = list(video['id'] for video in api_response['items'])
  1470. video_ids += new_ids
  1471. limit = min(n, api_response['totalItems'])
  1472. pagenum += 1
  1473. if len(video_ids) > n:
  1474. video_ids = video_ids[:n]
  1475. videos = [self.url_result(video_id, 'Youtube', video_id=video_id)
  1476. for video_id in video_ids]
  1477. return self.playlist_result(videos, query)
  1478. class YoutubeSearchDateIE(YoutubeSearchIE):
  1479. IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
  1480. _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc&orderby=published'
  1481. _SEARCH_KEY = 'ytsearchdate'
  1482. IE_DESC = u'YouTube.com searches, newest videos first'
  1483. class YoutubeShowIE(InfoExtractor):
  1484. IE_DESC = u'YouTube.com (multi-season) shows'
  1485. _VALID_URL = r'https?://www\.youtube\.com/show/(.*)'
  1486. IE_NAME = u'youtube:show'
  1487. def _real_extract(self, url):
  1488. mobj = re.match(self._VALID_URL, url)
  1489. show_name = mobj.group(1)
  1490. webpage = self._download_webpage(url, show_name, u'Downloading show webpage')
  1491. # There's one playlist for each season of the show
  1492. m_seasons = list(re.finditer(r'href="(/playlist\?list=.*?)"', webpage))
  1493. self.to_screen(u'%s: Found %s seasons' % (show_name, len(m_seasons)))
  1494. return [self.url_result('https://www.youtube.com' + season.group(1), 'YoutubePlaylist') for season in m_seasons]
  1495. class YoutubeFeedsInfoExtractor(YoutubeBaseInfoExtractor):
  1496. """
  1497. Base class for extractors that fetch info from
  1498. http://www.youtube.com/feed_ajax
  1499. Subclasses must define the _FEED_NAME and _PLAYLIST_TITLE properties.
  1500. """
  1501. _LOGIN_REQUIRED = True
  1502. # use action_load_personal_feed instead of action_load_system_feed
  1503. _PERSONAL_FEED = False
  1504. @property
  1505. def _FEED_TEMPLATE(self):
  1506. action = 'action_load_system_feed'
  1507. if self._PERSONAL_FEED:
  1508. action = 'action_load_personal_feed'
  1509. return 'http://www.youtube.com/feed_ajax?%s=1&feed_name=%s&paging=%%s' % (action, self._FEED_NAME)
  1510. @property
  1511. def IE_NAME(self):
  1512. return u'youtube:%s' % self._FEED_NAME
  1513. def _real_initialize(self):
  1514. self._login()
  1515. def _real_extract(self, url):
  1516. feed_entries = []
  1517. paging = 0
  1518. for i in itertools.count(1):
  1519. info = self._download_webpage(self._FEED_TEMPLATE % paging,
  1520. u'%s feed' % self._FEED_NAME,
  1521. u'Downloading page %s' % i)
  1522. info = json.loads(info)
  1523. feed_html = info['feed_html']
  1524. m_ids = re.finditer(r'"/watch\?v=(.*?)["&]', feed_html)
  1525. ids = orderedSet(m.group(1) for m in m_ids)
  1526. feed_entries.extend(
  1527. self.url_result(video_id, 'Youtube', video_id=video_id)
  1528. for video_id in ids)
  1529. if info['paging'] is None:
  1530. break
  1531. paging = info['paging']
  1532. return self.playlist_result(feed_entries, playlist_title=self._PLAYLIST_TITLE)
  1533. class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor):
  1534. IE_DESC = u'YouTube.com subscriptions feed, "ytsubs" keyword(requires authentication)'
  1535. _VALID_URL = r'https?://www\.youtube\.com/feed/subscriptions|:ytsubs(?:criptions)?'
  1536. _FEED_NAME = 'subscriptions'
  1537. _PLAYLIST_TITLE = u'Youtube Subscriptions'
  1538. class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
  1539. IE_DESC = u'YouTube.com recommended videos, "ytrec" keyword (requires authentication)'
  1540. _VALID_URL = r'https?://www\.youtube\.com/feed/recommended|:ytrec(?:ommended)?'
  1541. _FEED_NAME = 'recommended'
  1542. _PLAYLIST_TITLE = u'Youtube Recommended videos'
  1543. class YoutubeWatchLaterIE(YoutubeFeedsInfoExtractor):
  1544. IE_DESC = u'Youtube watch later list, "ytwatchlater" keyword (requires authentication)'
  1545. _VALID_URL = r'https?://www\.youtube\.com/feed/watch_later|:ytwatchlater'
  1546. _FEED_NAME = 'watch_later'
  1547. _PLAYLIST_TITLE = u'Youtube Watch Later'
  1548. _PERSONAL_FEED = True
  1549. class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
  1550. IE_DESC = u'Youtube watch history, "ythistory" keyword (requires authentication)'
  1551. _VALID_URL = u'https?://www\.youtube\.com/feed/history|:ythistory'
  1552. _FEED_NAME = 'history'
  1553. _PERSONAL_FEED = True
  1554. _PLAYLIST_TITLE = u'Youtube Watch History'
  1555. class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
  1556. IE_NAME = u'youtube:favorites'
  1557. IE_DESC = u'YouTube.com favourite videos, "ytfav" keyword (requires authentication)'
  1558. _VALID_URL = r'https?://www\.youtube\.com/my_favorites|:ytfav(?:ou?rites)?'
  1559. _LOGIN_REQUIRED = True
  1560. def _real_extract(self, url):
  1561. webpage = self._download_webpage('https://www.youtube.com/my_favorites', 'Youtube Favourites videos')
  1562. playlist_id = self._search_regex(r'list=(.+?)["&]', webpage, u'favourites playlist id')
  1563. return self.url_result(playlist_id, 'YoutubePlaylist')
  1564. class YoutubeTruncatedURLIE(InfoExtractor):
  1565. IE_NAME = 'youtube:truncated_url'
  1566. IE_DESC = False # Do not list
  1567. _VALID_URL = r'(?:https?://)?[^/]+/watch\?feature=[a-z_]+$'
  1568. def _real_extract(self, url):
  1569. raise ExtractorError(
  1570. u'Did you forget to quote the URL? Remember that & is a meta '
  1571. u'character in most shells, so you want to put the URL in quotes, '
  1572. u'like youtube-dl '
  1573. u'"http://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
  1574. u' or simply youtube-dl BaW_jenozKc .',
  1575. expected=True)