X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=youtube-dl;h=345bf4df9f8bff67a63836332024999e8440b3ec;hb=d0a9affb46f27a5afd5a6a76fdbc843d7189a1ad;hp=1ad297c26dd62eb484eb576cfb9711404636851e;hpb=d1580ed9908f10d6eb550e1ce8c31d3bc6921570;p=youtube-dl diff --git a/youtube-dl b/youtube-dl index 1ad297c26..345bf4df9 100755 --- a/youtube-dl +++ b/youtube-dl @@ -1,6 +1,7 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- # Author: Ricardo Garcia Gonzalez +# Author: Danny Colligan # License: Public domain code import htmlentitydefs import httplib @@ -70,10 +71,10 @@ class FileDownloader(object): File downloaders accept a lot of parameters. In order not to saturate the object constructor with arguments, it receives a dictionary of - options instead. These options are available through the get_params() - method for the InfoExtractors to use. The FileDownloader also registers - itself as the downloader in charge for the InfoExtractors that are - added to it, so this is a "mutual registration". + options instead. These options are available through the params + attribute for the InfoExtractors to use. The FileDownloader also + registers itself as the downloader in charge for the InfoExtractors + that are added to it, so this is a "mutual registration". Available options: @@ -88,9 +89,10 @@ class FileDownloader(object): outtmpl: Template for output names. ignoreerrors: Do not stop on download errors. ratelimit: Download speed limit, in bytes/sec. + nooverwrites: Prevent overwriting files. """ - _params = None + params = None _ies = [] _pps = [] @@ -98,7 +100,7 @@ class FileDownloader(object): """Create a FileDownloader object with the given options.""" self._ies = [] self._pps = [] - self.set_params(params) + self.params = params @staticmethod def pmkdir(filename): @@ -142,7 +144,7 @@ class FileDownloader(object): return '--:--' return '%02d:%02d' % (eta_mins, eta_secs) - @staticmethod + @staticmethod def calc_speed(start, now, bytes): dif = now - start if bytes == 0 or dif < 0.001: # One millisecond @@ -172,16 +174,6 @@ class FileDownloader(object): multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower()) return long(round(number * multiplier)) - def set_params(self, params): - """Sets parameters.""" - if type(params) != dict: - raise ValueError('params: dictionary expected') - self._params = params - - def get_params(self): - """Get parameters.""" - return self._params - def add_info_extractor(self, ie): """Add an InfoExtractor object to the end of the list.""" self._ies.append(ie) @@ -194,7 +186,7 @@ class FileDownloader(object): def to_stdout(self, message, skip_eol=False): """Print message to stdout if not in quiet mode.""" - if not self._params.get('quiet', False): + if not self.params.get('quiet', False): print u'%s%s' % (message, [u'\n', u''][skip_eol]), sys.stdout.flush() @@ -204,7 +196,7 @@ class FileDownloader(object): def fixed_template(self): """Checks if the output template is fixed.""" - return (re.search(ur'(?u)%\(.+?\)s', self._params['outtmpl']) is None) + return (re.search(ur'(?u)%\(.+?\)s', self.params['outtmpl']) is None) def trouble(self, message=None): """Determine action to take when a download problem appears. @@ -217,13 +209,13 @@ class FileDownloader(object): """ if message is not None: self.to_stderr(message) - if not self._params.get('ignoreerrors', False): + if not self.params.get('ignoreerrors', False): raise DownloadError(message) return 1 def slow_down(self, start_time, byte_counter): """Sleep if the download speed is over the rate limit.""" - rate_limit = self._params.get('ratelimit', None) + rate_limit = self.params.get('ratelimit', None) if rate_limit is None or byte_counter == 0: return now = time.time() @@ -251,7 +243,7 @@ class FileDownloader(object): """Download a given list of URLs.""" retcode = 0 if len(url_list) > 1 and self.fixed_template(): - raise SameFileError(self._params['outtmpl']) + raise SameFileError(self.params['outtmpl']) for url in url_list: suitable_found = False @@ -266,25 +258,28 @@ class FileDownloader(object): retcode = self.trouble() if len(results) > 1 and self.fixed_template(): - raise SameFileError(self._params['outtmpl']) + raise SameFileError(self.params['outtmpl']) for result in results: # Forced printings - if self._params.get('forcetitle', False): + if self.params.get('forcetitle', False): print result['title'] - if self._params.get('forceurl', False): + if self.params.get('forceurl', False): print result['url'] # Do nothing else if in simulate mode - if self._params.get('simulate', False): + if self.params.get('simulate', False): continue try: - filename = self._params['outtmpl'] % result + filename = self.params['outtmpl'] % result self.report_destination(filename) except (ValueError, KeyError), err: retcode = self.trouble('ERROR: invalid output template or system charset: %s' % str(err)) continue + if self.params['nooverwrites'] and os.path.exists(filename): + self.to_stderr('WARNING: file exists: %s; skipping' % filename) + continue try: self.pmkdir(filename) except (OSError, IOError), err: @@ -412,7 +407,7 @@ class InfoExtractor(object): def to_stdout(self, message): """Print message to stdout if downloader is not in quiet mode.""" - if self._downloader is None or not self._downloader.get_params().get('quiet', False): + if self._downloader is None or not self._downloader.params.get('quiet', False): print message def to_stderr(self, message): @@ -470,7 +465,7 @@ class YoutubeIE(InfoExtractor): username = None password = None - downloader_params = self._downloader.get_params() + downloader_params = self._downloader.params # Attempt to use provided username and password or .netrc data if downloader_params.get('username', None) is not None: @@ -488,12 +483,8 @@ class YoutubeIE(InfoExtractor): self.to_stderr(u'WARNING: parsing .netrc: %s' % str(err)) return - # No authentication to be performed - if username is None: - return - # Set language - request = urllib2.Request(self._LOGIN_URL, None, std_headers) + request = urllib2.Request(self._LANG_URL, None, std_headers) try: self.report_lang() urllib2.urlopen(request).read() @@ -501,6 +492,10 @@ class YoutubeIE(InfoExtractor): self.to_stderr(u'WARNING: unable to set language: %s' % str(err)) return + # No authentication to be performed + if username is None: + return + # Log in login_form = { 'current_form': 'loginForm', @@ -544,7 +539,7 @@ class YoutubeIE(InfoExtractor): # Downloader parameters format_param = None if self._downloader is not None: - params = self._downloader.get_params() + params = self._downloader.params format_param = params.get('format', None) # Extension @@ -721,6 +716,90 @@ class MetacafeIE(InfoExtractor): 'ext': video_extension.decode('utf-8'), }] + +class YoutubeSearchIE(InfoExtractor): + """Information Extractor for YouTube search queries.""" + _VALID_QUERY = r'ytsearch(\d+|all)?:[\s\S]+' + _TEMPLATE_URL = 'http://www.youtube.com/results?search_query=%s&page=%s&gl=US&hl=en' + _VIDEO_INDICATOR = r'href="/watch\?v=.+?"' + _MORE_PAGES_INDICATOR = r'>Next' + _youtube_ie = None + + def __init__(self, youtube_ie, downloader=None): + InfoExtractor.__init__(self, downloader) + self._youtube_ie = youtube_ie + + @staticmethod + def suitable(url): + return (re.match(YoutubeSearchIE._VALID_QUERY, url) is not None) + + def report_download_page(self, query, pagenum): + """Report attempt to download playlist page with given number.""" + self.to_stdout(u'[youtube] query "%s": Downloading page %s' % (query, pagenum)) + + def _real_initialize(self): + self._youtube_ie.initialize() + + def _real_extract(self, query): + mobj = re.match(self._VALID_QUERY, query) + if mobj is None: + self.to_stderr(u'ERROR: invalid search query "%s"' % query) + return [None] + + prefix, query = query.split(':') + prefix = prefix[8:] + if prefix == '': + return self._download_n_results(query, 1) + elif prefix == 'all': + return self._download_n_results(query, -1) + else: + try: + n = int(prefix) + if n <= 0: + self.to_stderr(u'ERROR: invalid download number %s for query "%s"' % (n, query)) + return [None] + return self._download_n_results(query, n) + except ValueError: # parsing prefix as int fails + return self._download_n_results(query, 1) + + def _download_n_results(self, query, n): + """Downloads a specified number of results for a query""" + + video_ids = [] + already_seen = set() + pagenum = 1 + + while True: + self.report_download_page(query, pagenum) + result_url = self._TEMPLATE_URL % (urllib.quote_plus(query), pagenum) + request = urllib2.Request(result_url, None, std_headers) + try: + page = urllib2.urlopen(request).read() + except (urllib2.URLError, httplib.HTTPException, socket.error), err: + self.to_stderr(u'ERROR: unable to download webpage: %s' % str(err)) + return [None] + + # Extract video identifiers + for mobj in re.finditer(self._VIDEO_INDICATOR, page): + video_id = page[mobj.span()[0]:mobj.span()[1]].split('=')[2][:-1] + if video_id not in already_seen: + video_ids.append(video_id) + already_seen.add(video_id) + if len(video_ids) == n: + # Specified n videos reached + information = [] + for id in video_ids: + information.extend(self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)) + return information + + if self._MORE_PAGES_INDICATOR not in page: + information = [] + for id in video_ids: + information.extend(self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)) + return information + + pagenum = pagenum + 1 + class YoutubePlaylistIE(InfoExtractor): """Information Extractor for YouTube playlists.""" @@ -806,7 +885,7 @@ class PostProcessor(object): def to_stdout(self, message): """Print message to stdout if downloader is not in quiet mode.""" - if self._downloader is None or not self._downloader.get_params().get('quiet', False): + if self._downloader is None or not self._downloader.params.get('quiet', False): print message def to_stderr(self, message): @@ -852,7 +931,7 @@ if __name__ == '__main__': # Parse command line parser = optparse.OptionParser( usage='Usage: %prog [options] url...', - version='2009.01.31', + version='INTERNAL', conflict_handler='resolve', ) parser.add_option('-h', '--help', @@ -891,6 +970,8 @@ if __name__ == '__main__': dest='ratelimit', metavar='L', help='download rate limit (e.g. 50k or 44.6m)') parser.add_option('-a', '--batch-file', dest='batchfile', metavar='F', help='file containing URLs to download') + parser.add_option('-w', '--no-overwrites', + action='store_true', dest='nooverwrites', help='do not overwrite files', default=False) (opts, args) = parser.parse_args() # Batch file verification @@ -925,6 +1006,7 @@ if __name__ == '__main__': youtube_ie = YoutubeIE() metacafe_ie = MetacafeIE(youtube_ie) youtube_pl_ie = YoutubePlaylistIE(youtube_ie) + youtube_search_ie = YoutubeSearchIE(youtube_ie) # File downloader charset = locale.getdefaultlocale()[1] @@ -945,7 +1027,9 @@ if __name__ == '__main__': or u'%(id)s.%(ext)s'), 'ignoreerrors': opts.ignoreerrors, 'ratelimit': opts.ratelimit, + 'nooverwrites': opts.nooverwrites, }) + fd.add_info_extractor(youtube_search_ie) fd.add_info_extractor(youtube_pl_ie) fd.add_info_extractor(metacafe_ie) fd.add_info_extractor(youtube_ie)