Raphaël G. Git Repositories - youtubedl/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                        (requires writesubtitles or writeautomaticsub)
  78     listsubtitles:     Lists all available subtitles for the video
  79     subtitlesformat:   Subtitle format [srt/sbv/vtt] (default=srt)
  80     subtitleslangs:    List of languages of the subtitles to download
  81     keepvideo:         Keep the video file after post-processing
  82     daterange:         A DateRange object, download only if the upload_date is in the range.
  83     skip_download:     Skip the actual download of the video file
  84     cachedir:          Location of the cache files in the filesystem.
  85                        None to disable filesystem cache.
  86
  87     The following parameters are not used by YoutubeDL itself, they are used by
  88     the FileDownloader:
  89     nopart, updatetime, buffersize, ratelimit, min_filesize, max_filesize, test,
  90     noresizebuffer, retries, continuedl, noprogress, consoletitle
  91     """
  92
  93     params = None
  94     _ies = []
  95     _pps = []
  96     _download_retcode = None
  97     _num_downloads = None
  98     _screen_file = None
  99
 100     def __init__(self, params):
 101         """Create a FileDownloader object with the given options."""
 102         self._ies = []
 103         self._ies_instances = {}
 104         self._pps = []
 105         self._progress_hooks = []
 106         self._download_retcode = 0
 107         self._num_downloads = 0
 108         self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
 109
 110         if (sys.version_info >= (3,) and sys.platform != 'win32' and
 111                 sys.getfilesystemencoding() in ['ascii', 'ANSI_X3.4-1968']
 112                 and not params['restrictfilenames']):
 113             # On Python 3, the Unicode filesystem API will throw errors (#1474)
 114             self.report_warning(
 115                 u'Assuming --restrict-filenames isnce file system encoding '
 116                 u'cannot encode all charactes. '
 117                 u'Set the LC_ALL environment variable to fix this.')
 118             params['restrictfilenames'] = True
 119
 120         self.params = params
 121         self.fd = FileDownloader(self, self.params)
 122
 123         if '%(stitle)s' in self.params['outtmpl']:
 124             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.')
 125
 126     def add_info_extractor(self, ie):
 127         """Add an InfoExtractor object to the end of the list."""
 128         self._ies.append(ie)
 129         self._ies_instances[ie.ie_key()] = ie
 130         ie.set_downloader(self)
 131
 132     def get_info_extractor(self, ie_key):
 133         """
 134         Get an instance of an IE with name ie_key, it will try to get one from
 135         the _ies list, if there's no instance it will create a new one and add
 136         it to the extractor list.
 137         """
 138         ie = self._ies_instances.get(ie_key)
 139         if ie is None:
 140             ie = get_info_extractor(ie_key)()
 141             self.add_info_extractor(ie)
 142         return ie
 143
 144     def add_default_info_extractors(self):
 145         """
 146         Add the InfoExtractors returned by gen_extractors to the end of the list
 147         """
 148         for ie in gen_extractors():
 149             self.add_info_extractor(ie)
 150
 151     def add_post_processor(self, pp):
 152         """Add a PostProcessor object to the end of the chain."""
 153         self._pps.append(pp)
 154         pp.set_downloader(self)
 155
 156     def to_screen(self, message, skip_eol=False):
 157         """Print message to stdout if not in quiet mode."""
 158         if not self.params.get('quiet', False):
 159             terminator = [u'\n', u''][skip_eol]
 160             output = message + terminator
 161             write_string(output, self._screen_file)
 162
 163     def to_stderr(self, message):
 164         """Print message to stderr."""
 165         assert type(message) == type(u'')
 166         output = message + u'\n'
 167         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
 168             output = output.encode(preferredencoding())
 169         sys.stderr.write(output)
 170
 171     def fixed_template(self):
 172         """Checks if the output template is fixed."""
 173         return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
 174
 175     def trouble(self, message=None, tb=None):
 176         """Determine action to take when a download problem appears.
 177
 178         Depending on if the downloader has been configured to ignore
 179         download errors or not, this method may throw an exception or
 180         not when errors are found, after printing the message.
 181
 182         tb, if given, is additional traceback information.
 183         """
 184         if message is not None:
 185             self.to_stderr(message)
 186         if self.params.get('verbose'):
 187             if tb is None:
 188                 if sys.exc_info()[0]:  # if .trouble has been called from an except block
 189                     tb = u''
 190                     if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 191                         tb += u''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
 192                     tb += compat_str(traceback.format_exc())
 193                 else:
 194                     tb_data = traceback.format_list(traceback.extract_stack())
 195                     tb = u''.join(tb_data)
 196             self.to_stderr(tb)
 197         if not self.params.get('ignoreerrors', False):
 198             if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 199                 exc_info = sys.exc_info()[1].exc_info
 200             else:
 201                 exc_info = sys.exc_info()
 202             raise DownloadError(message, exc_info)
 203         self._download_retcode = 1
 204
 205     def report_warning(self, message):
 206         '''
 207         Print the message to stderr, it will be prefixed with 'WARNING:'
 208         If stderr is a tty file the 'WARNING:' will be colored
 209         '''
 210         if sys.stderr.isatty() and os.name != 'nt':
 211             _msg_header=u'\033[0;33mWARNING:\033[0m'
 212         else:
 213             _msg_header=u'WARNING:'
 214         warning_message=u'%s %s' % (_msg_header,message)
 215         self.to_stderr(warning_message)
 216
 217     def report_error(self, message, tb=None):
 218         '''
 219         Do the same as trouble, but prefixes the message with 'ERROR:', colored
 220         in red if stderr is a tty file.
 221         '''
 222         if sys.stderr.isatty() and os.name != 'nt':
 223             _msg_header = u'\033[0;31mERROR:\033[0m'
 224         else:
 225             _msg_header = u'ERROR:'
 226         error_message = u'%s %s' % (_msg_header, message)
 227         self.trouble(error_message, tb)
 228
 229     def slow_down(self, start_time, byte_counter):
 230         """Sleep if the download speed is over the rate limit."""
 231         rate_limit = self.params.get('ratelimit', None)
 232         if rate_limit is None or byte_counter == 0:
 233             return
 234         now = time.time()
 235         elapsed = now - start_time
 236         if elapsed <= 0.0:
 237             return
 238         speed = float(byte_counter) / elapsed
 239         if speed > rate_limit:
 240             time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
 241
 242     def report_writedescription(self, descfn):
 243         """ Report that the description file is being written """
 244         self.to_screen(u'[info] Writing video description to: ' + descfn)
 245
 246     def report_writesubtitles(self, sub_filename):
 247         """ Report that the subtitles file is being written """
 248         self.to_screen(u'[info] Writing video subtitles to: ' + sub_filename)
 249
 250     def report_writeinfojson(self, infofn):
 251         """ Report that the metadata file has been written """
 252         self.to_screen(u'[info] Video description metadata as JSON to: ' + infofn)
 253
 254     def report_file_already_downloaded(self, file_name):
 255         """Report file has already been fully downloaded."""
 256         try:
 257             self.to_screen(u'[download] %s has already been downloaded' % file_name)
 258         except (UnicodeEncodeError) as err:
 259             self.to_screen(u'[download] The file has already been downloaded')
 260
 261     def increment_downloads(self):
 262         """Increment the ordinal that assigns a number to each file."""
 263         self._num_downloads += 1
 264
 265     def prepare_filename(self, info_dict):
 266         """Generate the output filename."""
 267         try:
 268             template_dict = dict(info_dict)
 269
 270             template_dict['epoch'] = int(time.time())
 271             autonumber_size = self.params.get('autonumber_size')
 272             if autonumber_size is None:
 273                 autonumber_size = 5
 274             autonumber_templ = u'%0' + str(autonumber_size) + u'd'
 275             template_dict['autonumber'] = autonumber_templ % self._num_downloads
 276             if template_dict['playlist_index'] is not None:
 277                 template_dict['playlist_index'] = u'%05d' % template_dict['playlist_index']
 278
 279             sanitize = lambda k,v: sanitize_filename(
 280                 u'NA' if v is None else compat_str(v),
 281                 restricted=self.params.get('restrictfilenames'),
 282                 is_id=(k==u'id'))
 283             template_dict = dict((k, sanitize(k, v)) for k,v in template_dict.items())
 284
 285             filename = self.params['outtmpl'] % template_dict
 286             return filename
 287         except KeyError as err:
 288             self.report_error(u'Erroneous output template')
 289             return None
 290         except ValueError as err:
 291             self.report_error(u'Error in output template: ' + str(err) + u' (encoding: ' + repr(preferredencoding()) + ')')
 292             return None
 293
 294     def _match_entry(self, info_dict):
 295         """ Returns None iff the file should be downloaded """
 296
 297         title = info_dict['title']
 298         matchtitle = self.params.get('matchtitle', False)
 299         if matchtitle:
 300             if not re.search(matchtitle, title, re.IGNORECASE):
 301                 return u'[download] "' + title + '" title did not match pattern "' + matchtitle + '"'
 302         rejecttitle = self.params.get('rejecttitle', False)
 303         if rejecttitle:
 304             if re.search(rejecttitle, title, re.IGNORECASE):
 305                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
 306         date = info_dict.get('upload_date', None)
 307         if date is not None:
 308             dateRange = self.params.get('daterange', DateRange())
 309             if date not in dateRange:
 310                 return u'[download] %s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
 311         return None
 312
 313     def extract_info(self, url, download=True, ie_key=None, extra_info={}):
 314         '''
 315         Returns a list with a dictionary for each video we find.
 316         If 'download', also downloads the videos.
 317         extra_info is a dict containing the extra values to add to each result
 318          '''
 319
 320         if ie_key:
 321             ies = [self.get_info_extractor(ie_key)]
 322         else:
 323             ies = self._ies
 324
 325         for ie in ies:
 326             if not ie.suitable(url):
 327                 continue
 328
 329             if not ie.working():
 330                 self.report_warning(u'The program functionality for this site has been marked as broken, '
 331                                     u'and will probably not work.')
 332
 333             try:
 334                 ie_result = ie.extract(url)
 335                 if ie_result is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
 336                     break
 337                 if isinstance(ie_result, list):
 338                     # Backwards compatibility: old IE result format
 339                     for result in ie_result:
 340                         result.update(extra_info)
 341                     ie_result = {
 342                         '_type': 'compat_list',
 343                         'entries': ie_result,
 344                     }
 345                 else:
 346                     ie_result.update(extra_info)
 347                 if 'extractor' not in ie_result:
 348                     ie_result['extractor'] = ie.IE_NAME
 349                 return self.process_ie_result(ie_result, download=download)
 350             except ExtractorError as de: # An error we somewhat expected
 351                 self.report_error(compat_str(de), de.format_traceback())
 352                 break
 353             except Exception as e:
 354                 if self.params.get('ignoreerrors', False):
 355                     self.report_error(compat_str(e), tb=compat_str(traceback.format_exc()))
 356                     break
 357                 else:
 358                     raise
 359         else:
 360             self.report_error(u'no suitable InfoExtractor: %s' % url)
 361
 362     def process_ie_result(self, ie_result, download=True, extra_info={}):
 363         """
 364         Take the result of the ie(may be modified) and resolve all unresolved
 365         references (URLs, playlist items).
 366
 367         It will also download the videos if 'download'.
 368         Returns the resolved ie_result.
 369         """
 370
 371         result_type = ie_result.get('_type', 'video') # If not given we suppose it's a video, support the default old system
 372         if result_type == 'video':
 373             ie_result.update(extra_info)
 374             if 'playlist' not in ie_result:
 375                 # It isn't part of a playlist
 376                 ie_result['playlist'] = None
 377                 ie_result['playlist_index'] = None
 378             if download:
 379                 self.process_info(ie_result)
 380             return ie_result
 381         elif result_type == 'url':
 382             # We have to add extra_info to the results because it may be
 383             # contained in a playlist
 384             return self.extract_info(ie_result['url'],
 385                                      download,
 386                                      ie_key=ie_result.get('ie_key'),
 387                                      extra_info=extra_info)
 388         elif result_type == 'playlist':
 389             # We process each entry in the playlist
 390             playlist = ie_result.get('title', None) or ie_result.get('id', None)
 391             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
 392
 393             playlist_results = []
 394
 395             n_all_entries = len(ie_result['entries'])
 396             playliststart = self.params.get('playliststart', 1) - 1
 397             playlistend = self.params.get('playlistend', -1)
 398
 399             if playlistend == -1:
 400                 entries = ie_result['entries'][playliststart:]
 401             else:
 402                 entries = ie_result['entries'][playliststart:playlistend]
 403
 404             n_entries = len(entries)
 405
 406             self.to_screen(u"[%s] playlist '%s': Collected %d video ids (downloading %d of them)" %
 407                 (ie_result['extractor'], playlist, n_all_entries, n_entries))
 408
 409             for i,entry in enumerate(entries,1):
 410                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
 411                 extra = {
 412                          'playlist': playlist,
 413                          'playlist_index': i + playliststart,
 414                          }
 415                 if not 'extractor' in entry:
 416                     # We set the extractor, if it's an url it will be set then to
 417                     # the new extractor, but if it's already a video we must make
 418                     # sure it's present: see issue #877
 419                     entry['extractor'] = ie_result['extractor']
 420                 entry_result = self.process_ie_result(entry,
 421                                                       download=download,
 422                                                       extra_info=extra)
 423                 playlist_results.append(entry_result)
 424             ie_result['entries'] = playlist_results
 425             return ie_result
 426         elif result_type == 'compat_list':
 427             def _fixup(r):
 428                 r.setdefault('extractor', ie_result['extractor'])
 429                 return r
 430             ie_result['entries'] = [
 431                 self.process_ie_result(_fixup(r), download=download)
 432                 for r in ie_result['entries']
 433             ]
 434             return ie_result
 435         else:
 436             raise Exception('Invalid result type: %s' % result_type)
 437
 438     def process_info(self, info_dict):
 439         """Process a single resolved IE result."""
 440
 441         assert info_dict.get('_type', 'video') == 'video'
 442         #We increment the download the download count here to match the previous behaviour.
 443         self.increment_downloads()
 444
 445         info_dict['fulltitle'] = info_dict['title']
 446         if len(info_dict['title']) > 200:
 447             info_dict['title'] = info_dict['title'][:197] + u'...'
 448
 449         # Keep for backwards compatibility
 450         info_dict['stitle'] = info_dict['title']
 451
 452         if not 'format' in info_dict:
 453             info_dict['format'] = info_dict['ext']
 454
 455         reason = self._match_entry(info_dict)
 456         if reason is not None:
 457             self.to_screen(u'[download] ' + reason)
 458             return
 459
 460         max_downloads = self.params.get('max_downloads')
 461         if max_downloads is not None:
 462             if self._num_downloads > int(max_downloads):
 463                 raise MaxDownloadsReached()
 464
 465         filename = self.prepare_filename(info_dict)
 466
 467         # Forced printings
 468         if self.params.get('forcetitle', False):
 469             compat_print(info_dict['title'])
 470         if self.params.get('forceid', False):
 471             compat_print(info_dict['id'])
 472         if self.params.get('forceurl', False):
 473             # For RTMP URLs, also include the playpath
 474             compat_print(info_dict['url'] + info_dict.get('play_path', u''))
 475         if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
 476             compat_print(info_dict['thumbnail'])
 477         if self.params.get('forcedescription', False) and 'description' in info_dict:
 478             compat_print(info_dict['description'])
 479         if self.params.get('forcefilename', False) and filename is not None:
 480             compat_print(filename)
 481         if self.params.get('forceformat', False):
 482             compat_print(info_dict['format'])
 483
 484         # Do nothing else if in simulate mode
 485         if self.params.get('simulate', False):
 486             return
 487
 488         if filename is None:
 489             return
 490
 491         try:
 492             dn = os.path.dirname(encodeFilename(filename))
 493             if dn != '' and not os.path.exists(dn):
 494                 os.makedirs(dn)
 495         except (OSError, IOError) as err:
 496             self.report_error(u'unable to create directory ' + compat_str(err))
 497             return
 498
 499         if self.params.get('writedescription', False):
 500             try:
 501                 descfn = filename + u'.description'
 502                 self.report_writedescription(descfn)
 503                 with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
 504                     descfile.write(info_dict['description'])
 505             except (KeyError, TypeError):
 506                 self.report_warning(u'There\'s no description to write.')
 507             except (OSError, IOError):
 508                 self.report_error(u'Cannot write description file ' + descfn)
 509                 return
 510
 511         subtitles_are_requested = any([self.params.get('writesubtitles', False),
 512                                        self.params.get('writeautomaticsub')])
 513
 514         if  subtitles_are_requested and 'subtitles' in info_dict and info_dict['subtitles']:
 515             # subtitles download errors are already managed as troubles in relevant IE
 516             # that way it will silently go on when used with unsupporting IE
 517             subtitles = info_dict['subtitles']
 518             sub_format = self.params.get('subtitlesformat')
 519             for sub_lang in subtitles.keys():
 520                 sub = subtitles[sub_lang]
 521                 if sub is None:
 522                     continue
 523                 try:
 524                     sub_filename = subtitles_filename(filename, sub_lang, 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 info_dict.get('thumbnail') is not None:
 544                 thumb_format = determine_ext(info_dict['thumbnail'], u'jpg')
 545                 thumb_filename = filename.rpartition('.')[0] + u'.' + thumb_format
 546                 self.to_screen(u'[%s] %s: Downloading thumbnail ...' %
 547                                (info_dict['extractor'], info_dict['id']))
 548                 try:
 549                     uf = compat_urllib_request.urlopen(info_dict['thumbnail'])
 550                     with open(thumb_filename, 'wb') as thumbf:
 551                         shutil.copyfileobj(uf, thumbf)
 552                     self.to_screen(u'[%s] %s: Writing thumbnail to: %s' %
 553                         (info_dict['extractor'], info_dict['id'], thumb_filename))
 554                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 555                     self.report_warning(u'Unable to download thumbnail "%s": %s' %
 556                         (info_dict['thumbnail'], compat_str(err)))
 557
 558         if not self.params.get('skip_download', False):
 559             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
 560                 success = True
 561             else:
 562                 try:
 563                     success = self.fd._do_download(filename, info_dict)
 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 (OSError, IOError) as err:
 568                     raise UnavailableVideoError(err)
 569                 except (ContentTooShortError, ) as err:
 570                     self.report_error(u'content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
 571                     return
 572
 573             if success:
 574                 try:
 575                     self.post_process(filename, info_dict)
 576                 except (PostProcessingError) as err:
 577                     self.report_error(u'postprocessing: %s' % str(err))
 578                     return
 579
 580     def download(self, url_list):
 581         """Download a given list of URLs."""
 582         if len(url_list) > 1 and self.fixed_template():
 583             raise SameFileError(self.params['outtmpl'])
 584
 585         for url in url_list:
 586             try:
 587                 #It also downloads the videos
 588                 videos = self.extract_info(url)
 589             except UnavailableVideoError:
 590                 self.report_error(u'unable to download video')
 591             except MaxDownloadsReached:
 592                 self.to_screen(u'[info] Maximum number of downloaded files reached.')
 593                 raise
 594
 595         return self._download_retcode
 596
 597     def post_process(self, filename, ie_info):
 598         """Run all the postprocessors on the given file."""
 599         info = dict(ie_info)
 600         info['filepath'] = filename
 601         keep_video = None
 602         for pp in self._pps:
 603             try:
 604                 keep_video_wish,new_info = pp.run(info)
 605                 if keep_video_wish is not None:
 606                     if keep_video_wish:
 607                         keep_video = keep_video_wish
 608                     elif keep_video is None:
 609                         # No clear decision yet, let IE decide
 610                         keep_video = keep_video_wish
 611             except PostProcessingError as e:
 612                 self.report_error(e.msg)
 613         if keep_video is False and not self.params.get('keepvideo', False):
 614             try:
 615                 self.to_screen(u'Deleting original file %s (pass -k to keep)' % filename)
 616                 os.remove(encodeFilename(filename))
 617             except (IOError, OSError):
 618                 self.report_warning(u'Unable to remove downloaded video file')