X-Git-Url: http://git.cielonegro.org/gitweb.cgi?a=blobdiff_plain;f=youtube-dl;h=496ae036fa7c98ed3166e0dfb16e857f4efad409;hb=2f11508adadc3a2bc5a7c0549071d114ae109a00;hp=5c3746b54110aceff9addbd2e4e12f4e299de206;hpb=9bf386d74bdc3e1785df03e24a7f875482b43705;p=youtube-dl.git diff --git a/youtube-dl b/youtube-dl index 5c3746b54..496ae036f 100755 --- a/youtube-dl +++ b/youtube-dl @@ -65,9 +65,10 @@ class FileDownloader(object): For this, file downloader objects have a method that allows InfoExtractors to be registered in a given order. When it is passed a URL, the file downloader handles it to the first InfoExtractor it - finds that reports being able to handle it. The InfoExtractor returns - all the information to the FileDownloader and the latter downloads the - file or does whatever it's instructed to do. + finds that reports being able to handle it. The InfoExtractor extracts + all the information about the video or videos the URL refers to, and + asks the FileDownloader to process the video information, possibly + downloading the video. File downloaders accept a lot of parameters. In order not to saturate the object constructor with arguments, it receives a dictionary of @@ -189,7 +190,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): - print u'%s%s' % (message, [u'\n', u''][skip_eol]), + print (u'%s%s' % (message, [u'\n', u''][skip_eol])).encode(locale.getpreferredencoding()), sys.stdout.flush() def to_stderr(self, message): @@ -243,9 +244,9 @@ class FileDownloader(object): """Process a single dictionary returned by an InfoExtractor.""" # Forced printings if self.params.get('forcetitle', False): - print info_dict['title'] + print info_dict['title'].encode(locale.getpreferredencoding()) if self.params.get('forceurl', False): - print info_dict['url'] + print info_dict['url'].encode(locale.getpreferredencoding()) # Do nothing else if in simulate mode if self.params.get('simulate', False): @@ -301,21 +302,8 @@ class FileDownloader(object): # Suitable InfoExtractor found suitable_found = True - # Extract information from URL - all_results = ie.extract(url) - results = [x for x in all_results if x is not None] - - # See if there were problems extracting any information - if len(results) != len(all_results): - self.trouble() - - # Two results could go to the same file - if len(results) > 1 and self.fixed_template(): - raise SameFileError(self.params['outtmpl']) - - # Process each result - for result in results: - self.process_info(result) + # Extract information from URL and process it + ie.extract(url) # Suitable InfoExtractor had been found; go to next URL break @@ -373,9 +361,10 @@ class InfoExtractor(object): Information extractors are the classes that, given a URL, extract information from the video (or videos) the URL refers to. This information includes the real video URL, the video title and simplified - title, author and others. It is returned in a list of dictionaries when - calling its extract() method. It is a list because a URL can refer to - more than one video (think of playlists). The dictionaries must include + title, author and others. The information is stored in a dictionary + which is then passed to the FileDownloader. The FileDownloader + processes this information possibly downloading the video to the file + system, among other possible outcomes. The dictionaries must include the following fields: id: Video identifier. @@ -419,15 +408,6 @@ class InfoExtractor(object): """Sets the downloader for this IE.""" self._downloader = downloader - 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.params.get('quiet', False): - print message - - def to_stderr(self, message): - """Print message to stderr.""" - print >>sys.stderr, message - def _real_initialize(self): """Real initialization process. Redefine in subclasses.""" pass @@ -474,27 +454,27 @@ class YoutubeIE(InfoExtractor): def report_lang(self): """Report attempt to set language.""" - self.to_stdout(u'[youtube] Setting language') + self._downloader.to_stdout(u'[youtube] Setting language') def report_login(self): """Report attempt to log in.""" - self.to_stdout(u'[youtube] Logging in') + self._downloader.to_stdout(u'[youtube] Logging in') def report_age_confirmation(self): """Report attempt to confirm age.""" - self.to_stdout(u'[youtube] Confirming age') + self._downloader.to_stdout(u'[youtube] Confirming age') def report_webpage_download(self, video_id): """Report attempt to download webpage.""" - self.to_stdout(u'[youtube] %s: Downloading video webpage' % video_id) + self._downloader.to_stdout(u'[youtube] %s: Downloading video webpage' % video_id) def report_information_extraction(self, video_id): """Report attempt to extract video information.""" - self.to_stdout(u'[youtube] %s: Extracting video information' % video_id) + self._downloader.to_stdout(u'[youtube] %s: Extracting video information' % video_id) def report_video_url(self, video_id, video_real_url): """Report extracted video URL.""" - self.to_stdout(u'[youtube] %s: URL: %s' % (video_id, video_real_url)) + self._downloader.to_stdout(u'[youtube] %s: URL: %s' % (video_id, video_real_url)) def _real_initialize(self): if self._downloader is None: @@ -517,7 +497,7 @@ class YoutubeIE(InfoExtractor): else: raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE) except (IOError, netrc.NetrcParseError), err: - self.to_stderr(u'WARNING: parsing .netrc: %s' % str(err)) + self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % str(err)) return # Set language @@ -526,7 +506,7 @@ class YoutubeIE(InfoExtractor): self.report_lang() urllib2.urlopen(request).read() except (urllib2.URLError, httplib.HTTPException, socket.error), err: - self.to_stderr(u'WARNING: unable to set language: %s' % str(err)) + self._downloader.to_stderr(u'WARNING: unable to set language: %s' % str(err)) return # No authentication to be performed @@ -546,10 +526,10 @@ class YoutubeIE(InfoExtractor): self.report_login() login_results = urllib2.urlopen(request).read() if re.search(r'(?i)