]>
Commit | Line | Data |
---|---|---|
1 | # encoding: utf-8 | |
2 | from __future__ import unicode_literals | |
3 | ||
4 | import re | |
5 | import itertools | |
6 | ||
7 | from .common import ( | |
8 | InfoExtractor, | |
9 | SearchInfoExtractor | |
10 | ) | |
11 | from ..compat import ( | |
12 | compat_str, | |
13 | compat_urlparse, | |
14 | compat_urllib_parse_urlencode, | |
15 | ) | |
16 | from ..utils import ( | |
17 | ExtractorError, | |
18 | int_or_none, | |
19 | unified_strdate, | |
20 | ) | |
21 | ||
22 | ||
23 | class SoundcloudIE(InfoExtractor): | |
24 | """Information extractor for soundcloud.com | |
25 | To access the media, the uid of the song and a stream token | |
26 | must be extracted from the page source and the script must make | |
27 | a request to media.soundcloud.com/crossdomain.xml. Then | |
28 | the media can be grabbed by requesting from an url composed | |
29 | of the stream token and uid | |
30 | """ | |
31 | ||
32 | _VALID_URL = r'''(?x)^(?:https?://)? | |
33 | (?:(?:(?:www\.|m\.)?soundcloud\.com/ | |
34 | (?P<uploader>[\w\d-]+)/ | |
35 | (?!(?:tracks|sets(?:/.+?)?|reposts|likes|spotlight)/?(?:$|[?#])) | |
36 | (?P<title>[\w\d-]+)/? | |
37 | (?P<token>[^?]+?)?(?:[?].*)?$) | |
38 | |(?:api\.soundcloud\.com/tracks/(?P<track_id>\d+) | |
39 | (?:/?\?secret_token=(?P<secret_token>[^&]+))?) | |
40 | |(?P<player>(?:w|player|p.)\.soundcloud\.com/player/?.*?url=.*) | |
41 | ) | |
42 | ''' | |
43 | IE_NAME = 'soundcloud' | |
44 | _TESTS = [ | |
45 | { | |
46 | 'url': 'http://soundcloud.com/ethmusic/lostin-powers-she-so-heavy', | |
47 | 'md5': 'ebef0a451b909710ed1d7787dddbf0d7', | |
48 | 'info_dict': { | |
49 | 'id': '62986583', | |
50 | 'ext': 'mp3', | |
51 | 'upload_date': '20121011', | |
52 | 'description': 'No Downloads untill we record the finished version this weekend, i was too pumped n i had to post it , earl is prolly gonna b hella p.o\'d', | |
53 | 'uploader': 'E.T. ExTerrestrial Music', | |
54 | 'title': 'Lostin Powers - She so Heavy (SneakPreview) Adrian Ackers Blueprint 1', | |
55 | 'duration': 143, | |
56 | 'license': 'all-rights-reserved', | |
57 | } | |
58 | }, | |
59 | # not streamable song | |
60 | { | |
61 | 'url': 'https://soundcloud.com/the-concept-band/goldrushed-mastered?in=the-concept-band/sets/the-royal-concept-ep', | |
62 | 'info_dict': { | |
63 | 'id': '47127627', | |
64 | 'ext': 'mp3', | |
65 | 'title': 'Goldrushed', | |
66 | 'description': 'From Stockholm Sweden\r\nPovel / Magnus / Filip / David\r\nwww.theroyalconcept.com', | |
67 | 'uploader': 'The Royal Concept', | |
68 | 'upload_date': '20120521', | |
69 | 'duration': 227, | |
70 | 'license': 'all-rights-reserved', | |
71 | }, | |
72 | 'params': { | |
73 | # rtmp | |
74 | 'skip_download': True, | |
75 | }, | |
76 | }, | |
77 | # private link | |
78 | { | |
79 | 'url': 'https://soundcloud.com/jaimemf/youtube-dl-test-video-a-y-baw/s-8Pjrp', | |
80 | 'md5': 'aa0dd32bfea9b0c5ef4f02aacd080604', | |
81 | 'info_dict': { | |
82 | 'id': '123998367', | |
83 | 'ext': 'mp3', | |
84 | 'title': 'Youtube - Dl Test Video \'\' Ä↭', | |
85 | 'uploader': 'jaimeMF', | |
86 | 'description': 'test chars: \"\'/\\ä↭', | |
87 | 'upload_date': '20131209', | |
88 | 'duration': 9, | |
89 | 'license': 'all-rights-reserved', | |
90 | }, | |
91 | }, | |
92 | # private link (alt format) | |
93 | { | |
94 | 'url': 'https://api.soundcloud.com/tracks/123998367?secret_token=s-8Pjrp', | |
95 | 'md5': 'aa0dd32bfea9b0c5ef4f02aacd080604', | |
96 | 'info_dict': { | |
97 | 'id': '123998367', | |
98 | 'ext': 'mp3', | |
99 | 'title': 'Youtube - Dl Test Video \'\' Ä↭', | |
100 | 'uploader': 'jaimeMF', | |
101 | 'description': 'test chars: \"\'/\\ä↭', | |
102 | 'upload_date': '20131209', | |
103 | 'duration': 9, | |
104 | 'license': 'all-rights-reserved', | |
105 | }, | |
106 | }, | |
107 | # downloadable song | |
108 | { | |
109 | 'url': 'https://soundcloud.com/oddsamples/bus-brakes', | |
110 | 'md5': '7624f2351f8a3b2e7cd51522496e7631', | |
111 | 'info_dict': { | |
112 | 'id': '128590877', | |
113 | 'ext': 'mp3', | |
114 | 'title': 'Bus Brakes', | |
115 | 'description': 'md5:0053ca6396e8d2fd7b7e1595ef12ab66', | |
116 | 'uploader': 'oddsamples', | |
117 | 'upload_date': '20140109', | |
118 | 'duration': 17, | |
119 | 'license': 'cc-by-sa', | |
120 | }, | |
121 | }, | |
122 | ] | |
123 | ||
124 | _CLIENT_ID = '02gUJC0hH2ct1EGOcYXQIzRFU91c72Ea' | |
125 | _IPHONE_CLIENT_ID = '376f225bf427445fc4bfb6b99b72e0bf' | |
126 | ||
127 | @staticmethod | |
128 | def _extract_urls(webpage): | |
129 | return [m.group('url') for m in re.finditer( | |
130 | r'<iframe[^>]+src=(["\'])(?P<url>(?:https?://)?(?:w\.)?soundcloud\.com/player.+?)\1', | |
131 | webpage)] | |
132 | ||
133 | def report_resolve(self, video_id): | |
134 | """Report information extraction.""" | |
135 | self.to_screen('%s: Resolving id' % video_id) | |
136 | ||
137 | @classmethod | |
138 | def _resolv_url(cls, url): | |
139 | return 'http://api.soundcloud.com/resolve.json?url=' + url + '&client_id=' + cls._CLIENT_ID | |
140 | ||
141 | def _extract_info_dict(self, info, full_title=None, quiet=False, secret_token=None): | |
142 | track_id = compat_str(info['id']) | |
143 | name = full_title or track_id | |
144 | if quiet: | |
145 | self.report_extraction(name) | |
146 | thumbnail = info.get('artwork_url') | |
147 | if isinstance(thumbnail, compat_str): | |
148 | thumbnail = thumbnail.replace('-large', '-t500x500') | |
149 | ext = 'mp3' | |
150 | result = { | |
151 | 'id': track_id, | |
152 | 'uploader': info.get('user', {}).get('username'), | |
153 | 'upload_date': unified_strdate(info.get('created_at')), | |
154 | 'title': info['title'], | |
155 | 'description': info.get('description'), | |
156 | 'thumbnail': thumbnail, | |
157 | 'duration': int_or_none(info.get('duration'), 1000), | |
158 | 'webpage_url': info.get('permalink_url'), | |
159 | 'license': info.get('license'), | |
160 | } | |
161 | formats = [] | |
162 | if info.get('downloadable', False): | |
163 | # We can build a direct link to the song | |
164 | format_url = ( | |
165 | 'https://api.soundcloud.com/tracks/{0}/download?client_id={1}'.format( | |
166 | track_id, self._CLIENT_ID)) | |
167 | formats.append({ | |
168 | 'format_id': 'download', | |
169 | 'ext': info.get('original_format', 'mp3'), | |
170 | 'url': format_url, | |
171 | 'vcodec': 'none', | |
172 | 'preference': 10, | |
173 | }) | |
174 | ||
175 | # We have to retrieve the url | |
176 | streams_url = ('http://api.soundcloud.com/i1/tracks/{0}/streams?' | |
177 | 'client_id={1}&secret_token={2}'.format(track_id, self._IPHONE_CLIENT_ID, secret_token)) | |
178 | format_dict = self._download_json( | |
179 | streams_url, | |
180 | track_id, 'Downloading track url') | |
181 | ||
182 | for key, stream_url in format_dict.items(): | |
183 | if key.startswith('http'): | |
184 | formats.append({ | |
185 | 'format_id': key, | |
186 | 'ext': ext, | |
187 | 'url': stream_url, | |
188 | 'vcodec': 'none', | |
189 | }) | |
190 | elif key.startswith('rtmp'): | |
191 | # The url doesn't have an rtmp app, we have to extract the playpath | |
192 | url, path = stream_url.split('mp3:', 1) | |
193 | formats.append({ | |
194 | 'format_id': key, | |
195 | 'url': url, | |
196 | 'play_path': 'mp3:' + path, | |
197 | 'ext': 'flv', | |
198 | 'vcodec': 'none', | |
199 | }) | |
200 | ||
201 | if not formats: | |
202 | # We fallback to the stream_url in the original info, this | |
203 | # cannot be always used, sometimes it can give an HTTP 404 error | |
204 | formats.append({ | |
205 | 'format_id': 'fallback', | |
206 | 'url': info['stream_url'] + '?client_id=' + self._CLIENT_ID, | |
207 | 'ext': ext, | |
208 | 'vcodec': 'none', | |
209 | }) | |
210 | ||
211 | for f in formats: | |
212 | if f['format_id'].startswith('http'): | |
213 | f['protocol'] = 'http' | |
214 | if f['format_id'].startswith('rtmp'): | |
215 | f['protocol'] = 'rtmp' | |
216 | ||
217 | self._check_formats(formats, track_id) | |
218 | self._sort_formats(formats) | |
219 | result['formats'] = formats | |
220 | ||
221 | return result | |
222 | ||
223 | def _real_extract(self, url): | |
224 | mobj = re.match(self._VALID_URL, url, flags=re.VERBOSE) | |
225 | if mobj is None: | |
226 | raise ExtractorError('Invalid URL: %s' % url) | |
227 | ||
228 | track_id = mobj.group('track_id') | |
229 | ||
230 | if track_id is not None: | |
231 | info_json_url = 'http://api.soundcloud.com/tracks/' + track_id + '.json?client_id=' + self._CLIENT_ID | |
232 | full_title = track_id | |
233 | token = mobj.group('secret_token') | |
234 | if token: | |
235 | info_json_url += '&secret_token=' + token | |
236 | elif mobj.group('player'): | |
237 | query = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query) | |
238 | real_url = query['url'][0] | |
239 | # If the token is in the query of the original url we have to | |
240 | # manually add it | |
241 | if 'secret_token' in query: | |
242 | real_url += '?secret_token=' + query['secret_token'][0] | |
243 | return self.url_result(real_url) | |
244 | else: | |
245 | # extract uploader (which is in the url) | |
246 | uploader = mobj.group('uploader') | |
247 | # extract simple title (uploader + slug of song title) | |
248 | slug_title = mobj.group('title') | |
249 | token = mobj.group('token') | |
250 | full_title = resolve_title = '%s/%s' % (uploader, slug_title) | |
251 | if token: | |
252 | resolve_title += '/%s' % token | |
253 | ||
254 | self.report_resolve(full_title) | |
255 | ||
256 | url = 'http://soundcloud.com/%s' % resolve_title | |
257 | info_json_url = self._resolv_url(url) | |
258 | info = self._download_json(info_json_url, full_title, 'Downloading info JSON') | |
259 | ||
260 | return self._extract_info_dict(info, full_title, secret_token=token) | |
261 | ||
262 | ||
263 | class SoundcloudBaseIE(SoundcloudIE): | |
264 | @staticmethod | |
265 | def _extract_id(e): | |
266 | return compat_str(e['id']) if e.get('id') else None | |
267 | ||
268 | def _extract_track_entries(self, tracks): | |
269 | return [ | |
270 | self.url_result( | |
271 | track['permalink_url'], SoundcloudIE.ie_key(), | |
272 | video_id=self._extract_id(track)) | |
273 | for track in tracks if track.get('permalink_url')] | |
274 | ||
275 | ||
276 | class SoundcloudSetIE(SoundcloudBaseIE): | |
277 | _VALID_URL = r'https?://(?:(?:www|m)\.)?soundcloud\.com/(?P<uploader>[\w\d-]+)/sets/(?P<slug_title>[\w\d-]+)(?:/(?P<token>[^?/]+))?' | |
278 | IE_NAME = 'soundcloud:set' | |
279 | _TESTS = [{ | |
280 | 'url': 'https://soundcloud.com/the-concept-band/sets/the-royal-concept-ep', | |
281 | 'info_dict': { | |
282 | 'id': '2284613', | |
283 | 'title': 'The Royal Concept EP', | |
284 | }, | |
285 | 'playlist_mincount': 6, | |
286 | }, { | |
287 | 'url': 'https://soundcloud.com/the-concept-band/sets/the-royal-concept-ep/token', | |
288 | 'only_matching': True, | |
289 | }] | |
290 | ||
291 | def _real_extract(self, url): | |
292 | mobj = re.match(self._VALID_URL, url) | |
293 | ||
294 | # extract uploader (which is in the url) | |
295 | uploader = mobj.group('uploader') | |
296 | # extract simple title (uploader + slug of song title) | |
297 | slug_title = mobj.group('slug_title') | |
298 | full_title = '%s/sets/%s' % (uploader, slug_title) | |
299 | url = 'http://soundcloud.com/%s/sets/%s' % (uploader, slug_title) | |
300 | ||
301 | token = mobj.group('token') | |
302 | if token: | |
303 | full_title += '/' + token | |
304 | url += '/' + token | |
305 | ||
306 | self.report_resolve(full_title) | |
307 | ||
308 | resolv_url = self._resolv_url(url) | |
309 | info = self._download_json(resolv_url, full_title) | |
310 | ||
311 | if 'errors' in info: | |
312 | msgs = (compat_str(err['error_message']) for err in info['errors']) | |
313 | raise ExtractorError('unable to download video webpage: %s' % ','.join(msgs)) | |
314 | ||
315 | entries = self._extract_track_entries(info['tracks']) | |
316 | ||
317 | return { | |
318 | '_type': 'playlist', | |
319 | 'entries': entries, | |
320 | 'id': '%s' % info['id'], | |
321 | 'title': info['title'], | |
322 | } | |
323 | ||
324 | ||
325 | class SoundcloudUserIE(SoundcloudBaseIE): | |
326 | _VALID_URL = r'''(?x) | |
327 | https?:// | |
328 | (?:(?:www|m)\.)?soundcloud\.com/ | |
329 | (?P<user>[^/]+) | |
330 | (?:/ | |
331 | (?P<rsrc>tracks|sets|reposts|likes|spotlight) | |
332 | )? | |
333 | /?(?:[?#].*)?$ | |
334 | ''' | |
335 | IE_NAME = 'soundcloud:user' | |
336 | _TESTS = [{ | |
337 | 'url': 'https://soundcloud.com/the-akashic-chronicler', | |
338 | 'info_dict': { | |
339 | 'id': '114582580', | |
340 | 'title': 'The Akashic Chronicler (All)', | |
341 | }, | |
342 | 'playlist_mincount': 74, | |
343 | }, { | |
344 | 'url': 'https://soundcloud.com/the-akashic-chronicler/tracks', | |
345 | 'info_dict': { | |
346 | 'id': '114582580', | |
347 | 'title': 'The Akashic Chronicler (Tracks)', | |
348 | }, | |
349 | 'playlist_mincount': 37, | |
350 | }, { | |
351 | 'url': 'https://soundcloud.com/the-akashic-chronicler/sets', | |
352 | 'info_dict': { | |
353 | 'id': '114582580', | |
354 | 'title': 'The Akashic Chronicler (Playlists)', | |
355 | }, | |
356 | 'playlist_mincount': 2, | |
357 | }, { | |
358 | 'url': 'https://soundcloud.com/the-akashic-chronicler/reposts', | |
359 | 'info_dict': { | |
360 | 'id': '114582580', | |
361 | 'title': 'The Akashic Chronicler (Reposts)', | |
362 | }, | |
363 | 'playlist_mincount': 7, | |
364 | }, { | |
365 | 'url': 'https://soundcloud.com/the-akashic-chronicler/likes', | |
366 | 'info_dict': { | |
367 | 'id': '114582580', | |
368 | 'title': 'The Akashic Chronicler (Likes)', | |
369 | }, | |
370 | 'playlist_mincount': 321, | |
371 | }, { | |
372 | 'url': 'https://soundcloud.com/grynpyret/spotlight', | |
373 | 'info_dict': { | |
374 | 'id': '7098329', | |
375 | 'title': 'GRYNPYRET (Spotlight)', | |
376 | }, | |
377 | 'playlist_mincount': 1, | |
378 | }] | |
379 | ||
380 | _API_BASE = 'https://api.soundcloud.com' | |
381 | _API_V2_BASE = 'https://api-v2.soundcloud.com' | |
382 | ||
383 | _BASE_URL_MAP = { | |
384 | 'all': '%s/profile/soundcloud:users:%%s' % _API_V2_BASE, | |
385 | 'tracks': '%s/users/%%s/tracks' % _API_BASE, | |
386 | 'sets': '%s/users/%%s/playlists' % _API_V2_BASE, | |
387 | 'reposts': '%s/profile/soundcloud:users:%%s/reposts' % _API_V2_BASE, | |
388 | 'likes': '%s/users/%%s/likes' % _API_V2_BASE, | |
389 | 'spotlight': '%s/users/%%s/spotlight' % _API_V2_BASE, | |
390 | } | |
391 | ||
392 | _TITLE_MAP = { | |
393 | 'all': 'All', | |
394 | 'tracks': 'Tracks', | |
395 | 'sets': 'Playlists', | |
396 | 'reposts': 'Reposts', | |
397 | 'likes': 'Likes', | |
398 | 'spotlight': 'Spotlight', | |
399 | } | |
400 | ||
401 | def _real_extract(self, url): | |
402 | mobj = re.match(self._VALID_URL, url) | |
403 | uploader = mobj.group('user') | |
404 | ||
405 | url = 'http://soundcloud.com/%s/' % uploader | |
406 | resolv_url = self._resolv_url(url) | |
407 | user = self._download_json( | |
408 | resolv_url, uploader, 'Downloading user info') | |
409 | ||
410 | resource = mobj.group('rsrc') or 'all' | |
411 | base_url = self._BASE_URL_MAP[resource] % user['id'] | |
412 | ||
413 | COMMON_QUERY = { | |
414 | 'limit': 50, | |
415 | 'client_id': self._CLIENT_ID, | |
416 | 'linked_partitioning': '1', | |
417 | } | |
418 | ||
419 | query = COMMON_QUERY.copy() | |
420 | query['offset'] = 0 | |
421 | ||
422 | next_href = base_url + '?' + compat_urllib_parse_urlencode(query) | |
423 | ||
424 | entries = [] | |
425 | for i in itertools.count(): | |
426 | response = self._download_json( | |
427 | next_href, uploader, 'Downloading track page %s' % (i + 1)) | |
428 | ||
429 | collection = response['collection'] | |
430 | if not collection: | |
431 | break | |
432 | ||
433 | def resolve_permalink_url(candidates): | |
434 | for cand in candidates: | |
435 | if isinstance(cand, dict): | |
436 | permalink_url = cand.get('permalink_url') | |
437 | entry_id = self._extract_id(cand) | |
438 | if permalink_url and permalink_url.startswith('http'): | |
439 | return permalink_url, entry_id | |
440 | ||
441 | for e in collection: | |
442 | permalink_url, entry_id = resolve_permalink_url((e, e.get('track'), e.get('playlist'))) | |
443 | if permalink_url: | |
444 | entries.append(self.url_result(permalink_url, video_id=entry_id)) | |
445 | ||
446 | next_href = response.get('next_href') | |
447 | if not next_href: | |
448 | break | |
449 | ||
450 | parsed_next_href = compat_urlparse.urlparse(response['next_href']) | |
451 | qs = compat_urlparse.parse_qs(parsed_next_href.query) | |
452 | qs.update(COMMON_QUERY) | |
453 | next_href = compat_urlparse.urlunparse( | |
454 | parsed_next_href._replace(query=compat_urllib_parse_urlencode(qs, True))) | |
455 | ||
456 | return { | |
457 | '_type': 'playlist', | |
458 | 'id': compat_str(user['id']), | |
459 | 'title': '%s (%s)' % (user['username'], self._TITLE_MAP[resource]), | |
460 | 'entries': entries, | |
461 | } | |
462 | ||
463 | ||
464 | class SoundcloudPlaylistIE(SoundcloudBaseIE): | |
465 | _VALID_URL = r'https?://api\.soundcloud\.com/playlists/(?P<id>[0-9]+)(?:/?\?secret_token=(?P<token>[^&]+?))?$' | |
466 | IE_NAME = 'soundcloud:playlist' | |
467 | _TESTS = [{ | |
468 | 'url': 'http://api.soundcloud.com/playlists/4110309', | |
469 | 'info_dict': { | |
470 | 'id': '4110309', | |
471 | 'title': 'TILT Brass - Bowery Poetry Club, August \'03 [Non-Site SCR 02]', | |
472 | 'description': 're:.*?TILT Brass - Bowery Poetry Club', | |
473 | }, | |
474 | 'playlist_count': 6, | |
475 | }] | |
476 | ||
477 | def _real_extract(self, url): | |
478 | mobj = re.match(self._VALID_URL, url) | |
479 | playlist_id = mobj.group('id') | |
480 | base_url = '%s//api.soundcloud.com/playlists/%s.json?' % (self.http_scheme(), playlist_id) | |
481 | ||
482 | data_dict = { | |
483 | 'client_id': self._CLIENT_ID, | |
484 | } | |
485 | token = mobj.group('token') | |
486 | ||
487 | if token: | |
488 | data_dict['secret_token'] = token | |
489 | ||
490 | data = compat_urllib_parse_urlencode(data_dict) | |
491 | data = self._download_json( | |
492 | base_url + data, playlist_id, 'Downloading playlist') | |
493 | ||
494 | entries = self._extract_track_entries(data['tracks']) | |
495 | ||
496 | return { | |
497 | '_type': 'playlist', | |
498 | 'id': playlist_id, | |
499 | 'title': data.get('title'), | |
500 | 'description': data.get('description'), | |
501 | 'entries': entries, | |
502 | } | |
503 | ||
504 | ||
505 | class SoundcloudSearchIE(SearchInfoExtractor, SoundcloudIE): | |
506 | IE_NAME = 'soundcloud:search' | |
507 | IE_DESC = 'Soundcloud search' | |
508 | _MAX_RESULTS = float('inf') | |
509 | _TESTS = [{ | |
510 | 'url': 'scsearch15:post-avant jazzcore', | |
511 | 'info_dict': { | |
512 | 'title': 'post-avant jazzcore', | |
513 | }, | |
514 | 'playlist_count': 15, | |
515 | }] | |
516 | ||
517 | _SEARCH_KEY = 'scsearch' | |
518 | _MAX_RESULTS_PER_PAGE = 200 | |
519 | _DEFAULT_RESULTS_PER_PAGE = 50 | |
520 | _API_V2_BASE = 'https://api-v2.soundcloud.com' | |
521 | ||
522 | def _get_collection(self, endpoint, collection_id, **query): | |
523 | limit = min( | |
524 | query.get('limit', self._DEFAULT_RESULTS_PER_PAGE), | |
525 | self._MAX_RESULTS_PER_PAGE) | |
526 | query['limit'] = limit | |
527 | query['client_id'] = self._CLIENT_ID | |
528 | query['linked_partitioning'] = '1' | |
529 | query['offset'] = 0 | |
530 | data = compat_urllib_parse_urlencode(query) | |
531 | next_url = '{0}{1}?{2}'.format(self._API_V2_BASE, endpoint, data) | |
532 | ||
533 | collected_results = 0 | |
534 | ||
535 | for i in itertools.count(1): | |
536 | response = self._download_json( | |
537 | next_url, collection_id, 'Downloading page {0}'.format(i), | |
538 | 'Unable to download API page') | |
539 | ||
540 | collection = response.get('collection', []) | |
541 | if not collection: | |
542 | break | |
543 | ||
544 | collection = list(filter(bool, collection)) | |
545 | collected_results += len(collection) | |
546 | ||
547 | for item in collection: | |
548 | yield self.url_result(item['uri'], SoundcloudIE.ie_key()) | |
549 | ||
550 | if not collection or collected_results >= limit: | |
551 | break | |
552 | ||
553 | next_url = response.get('next_href') | |
554 | if not next_url: | |
555 | break | |
556 | ||
557 | def _get_n_results(self, query, n): | |
558 | tracks = self._get_collection('/search/tracks', query, limit=n, q=query) | |
559 | return self.playlist_result(tracks, playlist_title=query) |