_ Git - youtube-dl/blob - youtube_dl/extractor/grooveshark.py

   1 # coding: utf-8
   2 from __future__ import unicode_literals
   3
   4 import time
   5 import math
   6 import re
   7 from urlparse import urlparse, urlunparse, urldefrag
   8 from urllib import quote, urlencode
   9 from os.path import basename
  10
  11 from .common import InfoExtractor
  12 from ..utils import ExtractorError, compat_urllib_request, compat_html_parser
  13
  14 class GroovesharkHtmlParser(compat_html_parser.HTMLParser):
  15     def __init__(self):
  16         self._current_object = None
  17         self.objects = []
  18         compat_html_parser.HTMLParser.__init__(self)
  19
  20     def handle_starttag(self, tag, attrs):
  21         attrs = dict((k, v) for k, v in attrs)
  22         if tag == 'object':
  23             self._current_object = { 'attrs': attrs, 'params': [] }
  24         elif tag == 'param':
  25             self._current_object['params'].append(attrs)
  26
  27     def handle_endtag(self, tag):
  28         if tag == 'object':
  29             self.objects.append(self._current_object)
  30             self._current_object = None
  31
  32     @classmethod
  33     def extract_object_tags(cls, html):
  34         p = cls()
  35         p.feed(html)
  36         p.close()
  37         return p.objects
  38
  39 class GroovesharkIE(InfoExtractor):
  40     _VALID_URL = r'https?://(www\.)?grooveshark\.com/#!/s/([^/]+)/([^/]+)'
  41     _TEST = {
  42         'url': 'http://grooveshark.com/#!/s/Jolene+Tenth+Key+Remix+Ft+Will+Sessions/6SS1DW?src=5',
  43         'md5': 'bbccc50b19daca23b8f961152c1dc95b',
  44         'info_dict': {
  45             'id': '6SS1DW',
  46             'title': 'Jolene (Tenth Key Remix ft. Will Sessions)',
  47             'ext': 'mp3',
  48             'duration': 227
  49         }
  50     }
  51
  52     do_playerpage_request = True
  53     do_bootstrap_request = True
  54
  55     def _parse_target(self, target):
  56         uri = urlparse(target)
  57         hash = uri.fragment[1:].split('?')[0]
  58         token = basename(hash.rstrip('/'))
  59         return (uri, hash, token)
  60
  61     def _build_bootstrap_url(self, target):
  62         (uri, hash, token) = self._parse_target(target)
  63         query = 'getCommunicationToken=1&hash=%s&%d' % (quote(hash, safe=''), self.ts)
  64         return (urlunparse((uri.scheme, uri.netloc, '/preload.php', None, query, None)), token)
  65
  66     def _build_meta_url(self, target):
  67         (uri, hash, token) = self._parse_target(target)
  68         query = 'hash=%s&%d' % (quote(hash, safe=''), self.ts)
  69         return (urlunparse((uri.scheme, uri.netloc, '/preload.php', None, query, None)), token)
  70
  71     def _build_stream_url(self, meta):
  72         return urlunparse(('http', meta['streamKey']['ip'], '/stream.php', None, None, None))
  73
  74     def _build_swf_referer(self, target, obj):
  75         (uri, _, _) = self._parse_target(target)
  76         return urlunparse((uri.scheme, uri.netloc, obj['attrs']['data'], None, None, None))
  77
  78     def _transform_bootstrap(self, js):
  79         return re.split('^\s*try\s*{', js, flags=re.M)[0] \
  80                  .split(' = ', 1)[1].strip().rstrip(';')
  81
  82     def _transform_meta(self, js):
  83         return js.split('\n')[0].split('=')[1].rstrip(';')
  84
  85     def _get_meta(self, target):
  86         (meta_url, token) = self._build_meta_url(target)
  87         self.to_screen('Metadata URL: %s' % meta_url)
  88
  89         headers = {'Referer': urldefrag(target)[0]}
  90         req = compat_urllib_request.Request(meta_url, headers=headers)
  91         res = self._download_json(req, token,
  92                                   transform_source=self._transform_meta)
  93
  94         if 'getStreamKeyWithSong' not in res:
  95             raise ExtractorError(
  96                 'Metadata not found. URL may be malformed, or Grooveshark API may have changed.')
  97
  98         if res['getStreamKeyWithSong'] is None:
  99             raise ExtractorError(
 100                 'Metadata download failed, probably due to Grooveshark anti-abuse throttling. Wait at least an hour before retrying from this IP.',
 101                 expected=True)
 102
 103         return res['getStreamKeyWithSong']
 104
 105     def _get_bootstrap(self, target):
 106         (bootstrap_url, token) = self._build_bootstrap_url(target)
 107
 108         headers = {'Referer': urldefrag(target)[0]}
 109         req = compat_urllib_request.Request(bootstrap_url, headers=headers)
 110         res = self._download_json(req, token, fatal=False,
 111                                   note='Downloading player bootstrap data',
 112                                   errnote='Unable to download player bootstrap data',
 113                                   transform_source=self._transform_bootstrap)
 114         return res
 115
 116     def _get_playerpage(self, target):
 117         (_, _, token) = self._parse_target(target)
 118
 119         res = self._download_webpage(
 120             target, token,
 121             note='Downloading player page',
 122             errnote='Unable to download player page',
 123             fatal=False)
 124
 125         if res is not None:
 126             o = GroovesharkHtmlParser.extract_object_tags(res)
 127             return (res, [x for x in o if x['attrs']['id'] == 'jsPlayerEmbed'])
 128
 129         return (res, None)
 130
 131     def _real_extract(self, url):
 132         (target_uri, _, token) = self._parse_target(url)
 133
 134         # 1. Fill cookiejar by making a request to the player page
 135         if self.do_playerpage_request:
 136             (_, player_objs) = self._get_playerpage(url)
 137             if player_objs is not None:
 138                 swf_referer = self._build_swf_referer(url, player_objs[0])
 139                 self.to_screen('SWF Referer: %s' % swf_referer)
 140
 141         # 2. Ask preload.php for swf bootstrap data to better mimic webapp
 142         if self.do_bootstrap_request:
 143             bootstrap = self._get_bootstrap(url)
 144             self.to_screen('CommunicationToken: %s' % bootstrap['getCommunicationToken'])
 145
 146         # 3. Ask preload.php for track metadata.
 147         meta = self._get_meta(url)
 148
 149         # 4. Construct stream request for track.
 150         stream_url = self._build_stream_url(meta)
 151         duration = int(math.ceil(float(meta['streamKey']['uSecs']) / 1000000))
 152         post_dict = {'streamKey': meta['streamKey']['streamKey']}
 153         post_data = urlencode(post_dict).encode('utf-8')
 154         headers = {
 155             'Content-Length': len(post_data),
 156             'Content-Type': 'application/x-www-form-urlencoded'
 157             }
 158
 159         if 'swf_referer' in locals():
 160             headers['Referer'] = swf_referer
 161
 162         req = compat_urllib_request.Request(streamurl, post_data, headers)
 163
 164         info_dict = {
 165             'id': token,
 166             'title': meta['song']['Name'],
 167             'http_method': 'POST',
 168             'url': stream_url,
 169             'ext': 'mp3',
 170             'format': 'mp3 audio',
 171             'duration': duration,
 172
 173             'post_data': post_data,
 174             'post_dict': post_dict,
 175             'headers': headers,
 176             'request': req
 177             }
 178
 179         if 'swf_referer' in locals():
 180             info_dict['http_referer'] = swf_referer
 181
 182         return info_dict
 183
 184     def _real_initialize(self):
 185         self.ts = int(time.time() * 1000)  # timestamp in millis
 186
 187     def _download_json(self, url_or_request, video_id,
 188                        note=u'Downloading JSON metadata',
 189                        errnote=u'Unable to download JSON metadata',
 190                        fatal=True,
 191                        transform_source=None):
 192         try:
 193             out = super(GroovesharkIE, self)._download_json(
 194                 url_or_request, video_id, note, errnote, transform_source)
 195             return out
 196         except ExtractorError as ee:
 197             if fatal:
 198                 raise ee
 199         return None
 200