_ Git - youtube-dl/blob - youtube_dl/YoutubeDL.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from __future__ import absolute_import
   5
   6 import io
   7 import os
   8 import re
   9 import shutil
  10 import socket
  11 import sys
  12 import time
  13 import traceback
  14
  15 from .utils import *
  16 from .extractor import get_info_extractor, gen_extractors
  17 from .FileDownloader import FileDownloader
  18
  19
  20 class YoutubeDL(object):
  21     """YoutubeDL class.
  22
  23     YoutubeDL objects are the ones responsible of downloading the
  24     actual video file and writing it to disk if the user has requested
  25     it, among some other tasks. In most cases there should be one per
  26     program. As, given a video URL, the downloader doesn't know how to
  27     extract all the needed information, task that InfoExtractors do, it
  28     has to pass the URL to one of them.
  29
  30     For this, YoutubeDL objects have a method that allows
  31     InfoExtractors to be registered in a given order. When it is passed
  32     a URL, the YoutubeDL object handles it to the first InfoExtractor it
  33     finds that reports being able to handle it. The InfoExtractor extracts
  34     all the information about the video or videos the URL refers to, and
  35     YoutubeDL process the extracted information, possibly using a File
  36     Downloader to download the video.
  37
  38     YoutubeDL objects accept a lot of parameters. In order not to saturate
  39     the object constructor with arguments, it receives a dictionary of
  40     options instead. These options are available through the params
  41     attribute for the InfoExtractors to use. The YoutubeDL also
  42     registers itself as the downloader in charge for the InfoExtractors
  43     that are added to it, so this is a "mutual registration".
  44
  45     Available options:
  46
  47     username:          Username for authentication purposes.
  48     password:          Password for authentication purposes.
  49     videopassword:     Password for acces a video.
  50     usenetrc:          Use netrc for authentication instead.
  51     verbose:           Print additional info to stdout.
  52     quiet:             Do not print messages to stdout.
  53     forceurl:          Force printing final URL.
  54     forcetitle:        Force printing title.
  55     forceid:           Force printing ID.
  56     forcethumbnail:    Force printing thumbnail URL.
  57     forcedescription:  Force printing description.
  58     forcefilename:     Force printing final filename.
  59     simulate:          Do not download the video files.
  60     format:            Video format code.
  61     format_limit:      Highest quality format to try.
  62     outtmpl:           Template for output names.
  63     restrictfilenames: Do not allow "&" and spaces in file names
  64     ignoreerrors:      Do not stop on download errors.
  65     nooverwrites:      Prevent overwriting files.
  66     playliststart:     Playlist item to start at.
  67     playlistend:       Playlist item to end at.
  68     matchtitle:        Download only matching titles.
  69     rejecttitle:       Reject downloads for matching titles.
  70     logtostderr:       Log messages to stderr instead of stdout.
  71     writedescription:  Write the video description to a .description file
  72     writeinfojson:     Write the video description to a .info.json file
  73     writethumbnail:    Write the thumbnail image to a file
  74     writesubtitles:    Write the video subtitles to a file
  75     writeautomaticsub: Write the automatic subtitles to a file
  76     allsubtitles:      Downloads all the subtitles of the video
  77     listsubtitles:     Lists all available subtitles for the video
  78     subtitlesformat:   Subtitle format [srt/sbv/vtt] (default=srt)
  79     subtitleslang:     Language of the subtitles to download
  80     keepvideo:         Keep the video file after post-processing
  81     daterange:         A DateRange object, download only if the upload_date is in the range.
  82     skip_download:     Skip the actual download of the video file
  83
  84     The following parameters are not used by YoutubeDL itself, they are used by
  85     the FileDownloader:
  86     nopart, updatetime, buffersize, ratelimit, min_filesize, max_filesize, test,
  87     noresizebuffer, retries, continuedl, noprogress, consoletitle
  88     """
  89
  90     params = None
  91     _ies = []
  92     _pps = []
  93     _download_retcode = None
  94     _num_downloads = None
  95     _screen_file = None
  96
  97     def __init__(self, params):
  98         """Create a FileDownloader object with the given options."""
  99         self._ies = []
 100         self._ies_instances = {}
 101         self._pps = []
 102         self._progress_hooks = []
 103         self._download_retcode = 0
 104         self._num_downloads = 0
 105         self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
 106         self.params = params
 107         self.fd = FileDownloader(self, self.params)
 108
 109         if '%(stitle)s' in self.params['outtmpl']:
 110             self.report_warning(u'%(stitle)s is deprecated. Use the %(title)s and the --restrict-filenames flag(which also secures %(uploader)s et al) instead.')
 111
 112     def add_info_extractor(self, ie):
 113         """Add an InfoExtractor object to the end of the list."""
 114         self._ies.append(ie)
 115         self._ies_instances[ie.ie_key()] = ie
 116         ie.set_downloader(self)
 117
 118     def get_info_extractor(self, ie_key):
 119         """
 120         Get an instance of an IE with name ie_key, it will try to get one from
 121         the _ies list, if there's no instance it will create a new one and add
 122         it to the extractor list.
 123         """
 124         ie = self._ies_instances.get(ie_key)
 125         if ie is None:
 126             ie = get_info_extractor(ie_key)()
 127             self.add_info_extractor(ie)
 128         return ie
 129
 130     def add_default_info_extractors(self):
 131         """
 132         Add the InfoExtractors returned by gen_extractors to the end of the list
 133         """
 134         for ie in gen_extractors():
 135             self.add_info_extractor(ie)
 136
 137     def add_post_processor(self, pp):
 138         """Add a PostProcessor object to the end of the chain."""
 139         self._pps.append(pp)
 140         pp.set_downloader(self)
 141
 142     def to_screen(self, message, skip_eol=False):
 143         """Print message to stdout if not in quiet mode."""
 144         assert type(message) == type(u'')
 145         if not self.params.get('quiet', False):
 146             terminator = [u'\n', u''][skip_eol]
 147             output = message + terminator
 148             if 'b' in getattr(self._screen_file, 'mode', '') or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
 149                 output = output.encode(preferredencoding(), 'ignore')
 150             self._screen_file.write(output)
 151             self._screen_file.flush()
 152
 153     def to_stderr(self, message):
 154         """Print message to stderr."""
 155         assert type(message) == type(u'')
 156         output = message + u'\n'
 157         if 'b' in getattr(self._screen_file, 'mode', '') or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
 158             output = output.encode(preferredencoding())
 159         sys.stderr.write(output)
 160
 161     def fixed_template(self):
 162         """Checks if the output template is fixed."""
 163         return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
 164
 165     def trouble(self, message=None, tb=None):
 166         """Determine action to take when a download problem appears.
 167
 168         Depending on if the downloader has been configured to ignore
 169         download errors or not, this method may throw an exception or
 170         not when errors are found, after printing the message.
 171
 172         tb, if given, is additional traceback information.
 173         """
 174         if message is not None:
 175             self.to_stderr(message)
 176         if self.params.get('verbose'):
 177             if tb is None:
 178                 if sys.exc_info()[0]:  # if .trouble has been called from an except block
 179                     tb = u''
 180                     if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 181                         tb += u''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
 182                     tb += compat_str(traceback.format_exc())
 183                 else:
 184                     tb_data = traceback.format_list(traceback.extract_stack())
 185                     tb = u''.join(tb_data)
 186             self.to_stderr(tb)
 187         if not self.params.get('ignoreerrors', False):
 188             if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 189                 exc_info = sys.exc_info()[1].exc_info
 190             else:
 191                 exc_info = sys.exc_info()
 192             raise DownloadError(message, exc_info)
 193         self._download_retcode = 1
 194
 195     def report_warning(self, message):
 196         '''
 197         Print the message to stderr, it will be prefixed with 'WARNING:'
 198         If stderr is a tty file the 'WARNING:' will be colored
 199         '''
 200         if sys.stderr.isatty() and os.name != 'nt':
 201             _msg_header=u'\033[0;33mWARNING:\033[0m'
 202         else:
 203             _msg_header=u'WARNING:'
 204         warning_message=u'%s %s' % (_msg_header,message)
 205         self.to_stderr(warning_message)
 206
 207     def report_error(self, message, tb=None):
 208         '''
 209         Do the same as trouble, but prefixes the message with 'ERROR:', colored
 210         in red if stderr is a tty file.
 211         '''
 212         if sys.stderr.isatty() and os.name != 'nt':
 213             _msg_header = u'\033[0;31mERROR:\033[0m'
 214         else:
 215             _msg_header = u'ERROR:'
 216         error_message = u'%s %s' % (_msg_header, message)
 217         self.trouble(error_message, tb)
 218
 219     def slow_down(self, start_time, byte_counter):
 220         """Sleep if the download speed is over the rate limit."""
 221         rate_limit = self.params.get('ratelimit', None)
 222         if rate_limit is None or byte_counter == 0:
 223             return
 224         now = time.time()
 225         elapsed = now - start_time
 226         if elapsed <= 0.0:
 227             return
 228         speed = float(byte_counter) / elapsed
 229         if speed > rate_limit:
 230             time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
 231
 232     def report_writedescription(self, descfn):
 233         """ Report that the description file is being written """
 234         self.to_screen(u'[info] Writing video description to: ' + descfn)
 235
 236     def report_writesubtitles(self, sub_filename):
 237         """ Report that the subtitles file is being written """
 238         self.to_screen(u'[info] Writing video subtitles to: ' + sub_filename)
 239
 240     def report_writeinfojson(self, infofn):
 241         """ Report that the metadata file has been written """
 242         self.to_screen(u'[info] Video description metadata as JSON to: ' + infofn)
 243
 244     def report_file_already_downloaded(self, file_name):
 245         """Report file has already been fully downloaded."""
 246         try:
 247             self.to_screen(u'[download] %s has already been downloaded' % file_name)
 248         except (UnicodeEncodeError) as err:
 249             self.to_screen(u'[download] The file has already been downloaded')
 250
 251     def increment_downloads(self):
 252         """Increment the ordinal that assigns a number to each file."""
 253         self._num_downloads += 1
 254
 255     def prepare_filename(self, info_dict):
 256         """Generate the output filename."""
 257         try:
 258             template_dict = dict(info_dict)
 259
 260             template_dict['epoch'] = int(time.time())
 261             autonumber_size = self.params.get('autonumber_size')
 262             if autonumber_size is None:
 263                 autonumber_size = 5
 264             autonumber_templ = u'%0' + str(autonumber_size) + u'd'
 265             template_dict['autonumber'] = autonumber_templ % self._num_downloads
 266             if template_dict['playlist_index'] is not None:
 267                 template_dict['playlist_index'] = u'%05d' % template_dict['playlist_index']
 268
 269             sanitize = lambda k,v: sanitize_filename(
 270                 u'NA' if v is None else compat_str(v),
 271                 restricted=self.params.get('restrictfilenames'),
 272                 is_id=(k==u'id'))
 273             template_dict = dict((k, sanitize(k, v)) for k,v in template_dict.items())
 274
 275             filename = self.params['outtmpl'] % template_dict
 276             return filename
 277         except KeyError as err:
 278             self.report_error(u'Erroneous output template')
 279             return None
 280         except ValueError as err:
 281             self.report_error(u'Insufficient system charset ' + repr(preferredencoding()))
 282             return None
 283
 284     def _match_entry(self, info_dict):
 285         """ Returns None iff the file should be downloaded """
 286
 287         title = info_dict['title']
 288         matchtitle = self.params.get('matchtitle', False)
 289         if matchtitle:
 290             if not re.search(matchtitle, title, re.IGNORECASE):
 291                 return u'[download] "' + title + '" title did not match pattern "' + matchtitle + '"'
 292         rejecttitle = self.params.get('rejecttitle', False)
 293         if rejecttitle:
 294             if re.search(rejecttitle, title, re.IGNORECASE):
 295                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
 296         date = info_dict.get('upload_date', None)
 297         if date is not None:
 298             dateRange = self.params.get('daterange', DateRange())
 299             if date not in dateRange:
 300                 return u'[download] %s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
 301         return None
 302
 303     def extract_info(self, url, download=True, ie_key=None, extra_info={}):
 304         '''
 305         Returns a list with a dictionary for each video we find.
 306         If 'download', also downloads the videos.
 307         extra_info is a dict containing the extra values to add to each result
 308          '''
 309
 310         if ie_key:
 311             ies = [self.get_info_extractor(ie_key)]
 312         else:
 313             ies = self._ies
 314
 315         for ie in ies:
 316             if not ie.suitable(url):
 317                 continue
 318
 319             if not ie.working():
 320                 self.report_warning(u'The program functionality for this site has been marked as broken, '
 321                                     u'and will probably not work.')
 322
 323             try:
 324                 ie_result = ie.extract(url)
 325                 if ie_result is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
 326                     break
 327                 if isinstance(ie_result, list):
 328                     # Backwards compatibility: old IE result format
 329                     for result in ie_result:
 330                         result.update(extra_info)
 331                     ie_result = {
 332                         '_type': 'compat_list',
 333                         'entries': ie_result,
 334                     }
 335                 else:
 336                     ie_result.update(extra_info)
 337                 if 'extractor' not in ie_result:
 338                     ie_result['extractor'] = ie.IE_NAME
 339                 return self.process_ie_result(ie_result, download=download)
 340             except ExtractorError as de: # An error we somewhat expected
 341                 self.report_error(compat_str(de), de.format_traceback())
 342                 break
 343             except Exception as e:
 344                 if self.params.get('ignoreerrors', False):
 345                     self.report_error(compat_str(e), tb=compat_str(traceback.format_exc()))
 346                     break
 347                 else:
 348                     raise
 349         else:
 350             self.report_error(u'no suitable InfoExtractor: %s' % url)
 351
 352     def process_ie_result(self, ie_result, download=True, extra_info={}):
 353         """
 354         Take the result of the ie(may be modified) and resolve all unresolved
 355         references (URLs, playlist items).
 356
 357         It will also download the videos if 'download'.
 358         Returns the resolved ie_result.
 359         """
 360
 361         result_type = ie_result.get('_type', 'video') # If not given we suppose it's a video, support the default old system
 362         if result_type == 'video':
 363             if 'playlist' not in ie_result:
 364                 # It isn't part of a playlist
 365                 ie_result['playlist'] = None
 366                 ie_result['playlist_index'] = None
 367             if download:
 368                 self.process_info(ie_result)
 369             return ie_result
 370         elif result_type == 'url':
 371             # We have to add extra_info to the results because it may be
 372             # contained in a playlist
 373             return self.extract_info(ie_result['url'],
 374                                      download,
 375                                      ie_key=ie_result.get('ie_key'),
 376                                      extra_info=extra_info)
 377         elif result_type == 'playlist':
 378             # We process each entry in the playlist
 379             playlist = ie_result.get('title', None) or ie_result.get('id', None)
 380             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
 381
 382             playlist_results = []
 383
 384             n_all_entries = len(ie_result['entries'])
 385             playliststart = self.params.get('playliststart', 1) - 1
 386             playlistend = self.params.get('playlistend', -1)
 387
 388             if playlistend == -1:
 389                 entries = ie_result['entries'][playliststart:]
 390             else:
 391                 entries = ie_result['entries'][playliststart:playlistend]
 392
 393             n_entries = len(entries)
 394
 395             self.to_screen(u"[%s] playlist '%s': Collected %d video ids (downloading %d of them)" %
 396                 (ie_result['extractor'], playlist, n_all_entries, n_entries))
 397
 398             for i,entry in enumerate(entries,1):
 399                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
 400                 extra = {
 401                          'playlist': playlist,
 402                          'playlist_index': i + playliststart,
 403                          }
 404                 if not 'extractor' in entry:
 405                     # We set the extractor, if it's an url it will be set then to
 406                     # the new extractor, but if it's already a video we must make
 407                     # sure it's present: see issue #877
 408                     entry['extractor'] = ie_result['extractor']
 409                 entry_result = self.process_ie_result(entry,
 410                                                       download=download,
 411                                                       extra_info=extra)
 412                 playlist_results.append(entry_result)
 413             ie_result['entries'] = playlist_results
 414             return ie_result
 415         elif result_type == 'compat_list':
 416             def _fixup(r):
 417                 r.setdefault('extractor', ie_result['extractor'])
 418                 return r
 419             ie_result['entries'] = [
 420                 self.process_ie_result(_fixup(r), download=download)
 421                 for r in ie_result['entries']
 422             ]
 423             return ie_result
 424         else:
 425             raise Exception('Invalid result type: %s' % result_type)
 426
 427     def process_info(self, info_dict):
 428         """Process a single resolved IE result."""
 429
 430         assert info_dict.get('_type', 'video') == 'video'
 431         #We increment the download the download count here to match the previous behaviour.
 432         self.increment_downloads()
 433
 434         info_dict['fulltitle'] = info_dict['title']
 435         if len(info_dict['title']) > 200:
 436             info_dict['title'] = info_dict['title'][:197] + u'...'
 437
 438         # Keep for backwards compatibility
 439         info_dict['stitle'] = info_dict['title']
 440
 441         if not 'format' in info_dict:
 442             info_dict['format'] = info_dict['ext']
 443
 444         reason = self._match_entry(info_dict)
 445         if reason is not None:
 446             self.to_screen(u'[download] ' + reason)
 447             return
 448
 449         max_downloads = self.params.get('max_downloads')
 450         if max_downloads is not None:
 451             if self._num_downloads > int(max_downloads):
 452                 raise MaxDownloadsReached()
 453
 454         filename = self.prepare_filename(info_dict)
 455
 456         # Forced printings
 457         if self.params.get('forcetitle', False):
 458             compat_print(info_dict['title'])
 459         if self.params.get('forceid', False):
 460             compat_print(info_dict['id'])
 461         if self.params.get('forceurl', False):
 462             compat_print(info_dict['url'])
 463         if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
 464             compat_print(info_dict['thumbnail'])
 465         if self.params.get('forcedescription', False) and 'description' in info_dict:
 466             compat_print(info_dict['description'])
 467         if self.params.get('forcefilename', False) and filename is not None:
 468             compat_print(filename)
 469         if self.params.get('forceformat', False):
 470             compat_print(info_dict['format'])
 471
 472         # Do nothing else if in simulate mode
 473         if self.params.get('simulate', False):
 474             return
 475
 476         if filename is None:
 477             return
 478
 479         try:
 480             dn = os.path.dirname(encodeFilename(filename))
 481             if dn != '' and not os.path.exists(dn):
 482                 os.makedirs(dn)
 483         except (OSError, IOError) as err:
 484             self.report_error(u'unable to create directory ' + compat_str(err))
 485             return
 486
 487         if self.params.get('writedescription', False):
 488             try:
 489                 descfn = filename + u'.description'
 490                 self.report_writedescription(descfn)
 491                 with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
 492                     descfile.write(info_dict['description'])
 493             except (OSError, IOError):
 494                 self.report_error(u'Cannot write description file ' + descfn)
 495                 return
 496
 497         if (self.params.get('writesubtitles', False) or self.params.get('writeautomaticsub')) and 'subtitles' in info_dict and info_dict['subtitles']:
 498             # subtitles download errors are already managed as troubles in relevant IE
 499             # that way it will silently go on when used with unsupporting IE
 500             subtitle = info_dict['subtitles'][0]
 501             (sub_error, sub_lang, sub) = subtitle
 502             sub_format = self.params.get('subtitlesformat')
 503             if sub_error:
 504                 self.report_warning("Some error while getting the subtitles")
 505             else:
 506                 try:
 507                     sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
 508                     self.report_writesubtitles(sub_filename)
 509                     with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
 510                         subfile.write(sub)
 511                 except (OSError, IOError):
 512                     self.report_error(u'Cannot write subtitles file ' + descfn)
 513                     return
 514
 515         if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
 516             subtitles = info_dict['subtitles']
 517             sub_format = self.params.get('subtitlesformat')
 518             for subtitle in subtitles:
 519                 (sub_error, sub_lang, sub) = subtitle
 520                 if sub_error:
 521                     self.report_warning("Some error while getting the subtitles")
 522                 else:
 523                     try:
 524                         sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
 525                         self.report_writesubtitles(sub_filename)
 526                         with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
 527                                 subfile.write(sub)
 528                     except (OSError, IOError):
 529                         self.report_error(u'Cannot write subtitles file ' + descfn)
 530                         return
 531
 532         if self.params.get('writeinfojson', False):
 533             infofn = filename + u'.info.json'
 534             self.report_writeinfojson(infofn)
 535             try:
 536                 json_info_dict = dict((k, v) for k,v in info_dict.items() if not k in ['urlhandle'])
 537                 write_json_file(json_info_dict, encodeFilename(infofn))
 538             except (OSError, IOError):
 539                 self.report_error(u'Cannot write metadata to JSON file ' + infofn)
 540                 return
 541
 542         if self.params.get('writethumbnail', False):
 543             if 'thumbnail' in info_dict:
 544                 thumb_format = info_dict['thumbnail'].rpartition(u'/')[2].rpartition(u'.')[2]
 545                 if not thumb_format:
 546                     thumb_format = 'jpg'
 547                 thumb_filename = filename.rpartition('.')[0] + u'.' + thumb_format
 548                 self.to_screen(u'[%s] %s: Downloading thumbnail ...' %
 549                                (info_dict['extractor'], info_dict['id']))
 550                 uf = compat_urllib_request.urlopen(info_dict['thumbnail'])
 551                 with open(thumb_filename, 'wb') as thumbf:
 552                     shutil.copyfileobj(uf, thumbf)
 553                 self.to_screen(u'[%s] %s: Writing thumbnail to: %s' %
 554                                (info_dict['extractor'], info_dict['id'], thumb_filename))
 555
 556         if not self.params.get('skip_download', False):
 557             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
 558                 success = True
 559             else:
 560                 try:
 561                     success = self.fd._do_download(filename, info_dict)
 562                 except (OSError, IOError) as err:
 563                     raise UnavailableVideoError()
 564                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 565                     self.report_error(u'unable to download video data: %s' % str(err))
 566                     return
 567                 except (ContentTooShortError, ) as err:
 568                     self.report_error(u'content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
 569                     return
 570
 571             if success:
 572                 try:
 573                     self.post_process(filename, info_dict)
 574                 except (PostProcessingError) as err:
 575                     self.report_error(u'postprocessing: %s' % str(err))
 576                     return
 577
 578     def download(self, url_list):
 579         """Download a given list of URLs."""
 580         if len(url_list) > 1 and self.fixed_template():
 581             raise SameFileError(self.params['outtmpl'])
 582
 583         for url in url_list:
 584             try:
 585                 #It also downloads the videos
 586                 videos = self.extract_info(url)
 587             except UnavailableVideoError:
 588                 self.report_error(u'unable to download video')
 589             except MaxDownloadsReached:
 590                 self.to_screen(u'[info] Maximum number of downloaded files reached.')
 591                 raise
 592
 593         return self._download_retcode
 594
 595     def post_process(self, filename, ie_info):
 596         """Run all the postprocessors on the given file."""
 597         info = dict(ie_info)
 598         info['filepath'] = filename
 599         keep_video = None
 600         for pp in self._pps:
 601             try:
 602                 keep_video_wish,new_info = pp.run(info)
 603                 if keep_video_wish is not None:
 604                     if keep_video_wish:
 605                         keep_video = keep_video_wish
 606                     elif keep_video is None:
 607                         # No clear decision yet, let IE decide
 608                         keep_video = keep_video_wish
 609             except PostProcessingError as e:
 610                 self.to_stderr(u'ERROR: ' + e.msg)
 611         if keep_video is False and not self.params.get('keepvideo', False):
 612             try:
 613                 self.to_screen(u'Deleting original file %s (pass -k to keep)' % filename)
 614                 os.remove(encodeFilename(filename))
 615             except (IOError, OSError):
 616                 self.report_warning(u'Unable to remove downloaded video file')