Change the order for extracting/downloading

Now it gets a video info and directly downloads it, the it pass to the next video founded.

youtube_dl/FileDownloader.py

@@ -419,9 +419,10 @@ def _match_entry(self, info_dict):
                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
         return None
         
-    def extract_info(self, url):
+    def extract_info(self, url, download = True):
         '''
         Returns a list with a dictionary for each video we find.
+        If 'download', also downloads the videos.
          '''
         suitable_found = False
         for ie in self._ies:
@@ -440,7 +441,12 @@ def extract_info(self, url):
             # Extract information from URL and process it
             try:
                 ie_results = ie.extract(url)
-                results = self.process_ie_results(ie_results, ie)
+                results = []
+                for ie_result in ie_results:
+                    if not 'extractor' in ie_result:
+                        #The extractor has already been set somewhere else
+                        ie_result['extractor'] = ie.IE_NAME
+                    results.append(self.process_ie_result(ie_result, download))
                 return results
             except ExtractorError as de: # An error we somewhat expected
                 self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
@@ -453,51 +459,51 @@ def extract_info(self, url):
                     raise
         if not suitable_found:
                 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
-    def extract_info_iterable(self, urls):
-        '''
-            Return the videos founded for the urls
-        '''
-        results = []
-        for url in urls:
-            results.extend(self.extract_info(url))
-        return results
         
-    def process_ie_results(self, ie_results, ie):
+    def process_ie_result(self, ie_result, download = True):
         """
-        Take the results of the ie and return a list of videos.
+        Take the result of the ie and return a list of videos.
-        For url elements it will seartch the suitable ie and get the videos
+        For url elements it will search the suitable ie and get the videos
         For playlist elements it will process each of the elements of the 'entries' key
+        
+        It will also download the videos if 'download'.
         """
-        results = [] 
+        result_type = ie_result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
-        for result in ie_results or []:
+        if result_type == 'video':
-            result_type = result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
+            if 'playlist' not in ie_result:
-            if result_type == 'video':
+                #It isn't part of a playlist
-                if not 'extractor' in result:
+                ie_result['playlist'] = None
-                    #The extractor has already been set somewhere else
+            if download:
-                    result['extractor'] = ie.IE_NAME
+                #Do the download:
-                results.append(result)
+                self.process_info(ie_result)
-            elif result_type == 'url':
+            return ie_result
-                #We get the videos pointed by the url
+        elif result_type == 'url':
-                results.extend(self.extract_info(result['url']))
+            #We get the video pointed by the url
-            elif result_type == 'playlist':
+            result = self.extract_info(ie_result['url'], download)[0]
-                #We process each entry in the playlist
+            return result
-                entries_result = self.process_ie_results(result['entries'], ie)
+        elif result_type == 'playlist':
-                result['entries'] = entries_result
+            #We process each entry in the playlist
-                results.extend([result])
+            playlist = ie_result.get('title', None) or ie_result.get('id', None)
-        return results
+            self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
+            n_videos = len(ie_result['entries'])
+            playlist_results = []
+            for i,entry in enumerate(ie_result['entries'],1):
+                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
+                entry_result = self.process_ie_result(entry, False)
+                entry_result['playlist'] = playlist
+                #We must do the download here to correctly set the 'playlist' key
+                if download:
+                    self.process_info(entry_result)
+                playlist_results.append(entry_result)
+            result = ie_result.copy()
+            result['entries'] = playlist_results
+            return result
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""
 
-        if info_dict.get('_type','video') == 'playlist':
+        #We increment the download the download count here to match the previous behaviour.
-            playlist = info_dict.get('title', None) or info_dict.get('id', None)
+        self.increment_downloads()
-            self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
-            n_videos = len(info_dict['entries'])
-            for i,video in enumerate(info_dict['entries'],1):
-                video['playlist'] = playlist
-                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
-                self.process_info(video)
-            return
         
         # Keep for backwards compatibility
         info_dict['stitle'] = info_dict['title']
@@ -633,17 +639,14 @@ def download(self, url_list):
             raise SameFileError(self.params['outtmpl'])
 
         for url in url_list:
-            videos = self.extract_info(url)
+            try:
-
+                #It also downloads the videos
-            for video in videos or []:
+                videos = self.extract_info(url)
-                try:
+            except UnavailableVideoError:
-                    self.increment_downloads()
+                self.trouble(u'\nERROR: unable to download video')
-                    self.process_info(video)
+            except MaxDownloadsReached:
-                except UnavailableVideoError:
+                self.to_screen(u'[info] Maximum number of downloaded files reached.')
-                    self.trouble(u'\nERROR: unable to download video')
+                raise
-                except MaxDownloadsReached:
-                    self.to_screen(u'[info] Maximum number of downloaded files reached.')
-                    raise
 
         return self._download_retcode