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