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

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from __future__ import absolute_import
   5
   6 import math
   7 import io
   8 import os
   9 import re
  10 import socket
  11 import subprocess
  12 import sys
  13 import time
  14 import traceback
  15
  16 if os.name == 'nt':
  17     import ctypes
  18
  19 from .utils import *
  20
  21
  22 class FileDownloader(object):
  23     """File Downloader class.
  24
  25     File downloader objects are the ones responsible of downloading the
  26     actual video file and writing it to disk if the user has requested
  27     it, among some other tasks. In most cases there should be one per
  28     program. As, given a video URL, the downloader doesn't know how to
  29     extract all the needed information, task that InfoExtractors do, it
  30     has to pass the URL to one of them.
  31
  32     For this, file downloader objects have a method that allows
  33     InfoExtractors to be registered in a given order. When it is passed
  34     a URL, the file downloader handles it to the first InfoExtractor it
  35     finds that reports being able to handle it. The InfoExtractor extracts
  36     all the information about the video or videos the URL refers to, and
  37     asks the FileDownloader to process the video information, possibly
  38     downloading the video.
  39
  40     File downloaders accept a lot of parameters. In order not to saturate
  41     the object constructor with arguments, it receives a dictionary of
  42     options instead. These options are available through the params
  43     attribute for the InfoExtractors to use. The FileDownloader also
  44     registers itself as the downloader in charge for the InfoExtractors
  45     that are added to it, so this is a "mutual registration".
  46
  47     Available options:
  48
  49     username:          Username for authentication purposes.
  50     password:          Password for authentication purposes.
  51     usenetrc:          Use netrc for authentication instead.
  52     quiet:             Do not print messages to stdout.
  53     forceurl:          Force printing final URL.
  54     forcetitle:        Force printing title.
  55     forcethumbnail:    Force printing thumbnail URL.
  56     forcedescription:  Force printing description.
  57     forcefilename:     Force printing final filename.
  58     simulate:          Do not download the video files.
  59     format:            Video format code.
  60     format_limit:      Highest quality format to try.
  61     outtmpl:           Template for output names.
  62     restrictfilenames: Do not allow "&" and spaces in file names
  63     ignoreerrors:      Do not stop on download errors.
  64     ratelimit:         Download speed limit, in bytes/sec.
  65     nooverwrites:      Prevent overwriting files.
  66     retries:           Number of times to retry for HTTP error 5xx
  67     buffersize:        Size of download buffer in bytes.
  68     noresizebuffer:    Do not automatically resize the download buffer.
  69     continuedl:        Try to continue downloads if possible.
  70     noprogress:        Do not print the progress bar.
  71     playliststart:     Playlist item to start at.
  72     playlistend:       Playlist item to end at.
  73     matchtitle:        Download only matching titles.
  74     rejecttitle:       Reject downloads for matching titles.
  75     logtostderr:       Log messages to stderr instead of stdout.
  76     consoletitle:      Display progress in console window's titlebar.
  77     nopart:            Do not use temporary .part files.
  78     updatetime:        Use the Last-modified header to set output file timestamps.
  79     writedescription:  Write the video description to a .description file
  80     writeinfojson:     Write the video description to a .info.json file
  81     writesubtitles:    Write the video subtitles to a file
  82     onlysubtitles:     Downloads only the subtitles of the video
  83     allsubtitles:      Downloads all the subtitles of the video
  84     listsubtitles:     Lists all available subtitles for the video
  85     subtitlesformat:   Subtitle format [sbv/srt] (default=srt)
  86     subtitleslang:     Language of the subtitles to download
  87     test:              Download only first bytes to test the downloader.
  88     keepvideo:         Keep the video file after post-processing
  89     min_filesize:      Skip files smaller than this size
  90     max_filesize:      Skip files larger than this size
  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._pps = []
 104         self._progress_hooks = []
 105         self._download_retcode = 0
 106         self._num_downloads = 0
 107         self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
 108         self.params = params
 109
 110         if '%(stitle)s' in self.params['outtmpl']:
 111             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.')
 112
 113     @staticmethod
 114     def format_bytes(bytes):
 115         if bytes is None:
 116             return 'N/A'
 117         if type(bytes) is str:
 118             bytes = float(bytes)
 119         if bytes == 0.0:
 120             exponent = 0
 121         else:
 122             exponent = int(math.log(bytes, 1024.0))
 123         suffix = 'bkMGTPEZY'[exponent]
 124         converted = float(bytes) / float(1024 ** exponent)
 125         return '%.2f%s' % (converted, suffix)
 126
 127     @staticmethod
 128     def calc_percent(byte_counter, data_len):
 129         if data_len is None:
 130             return '---.-%'
 131         return '%6s' % ('%3.1f%%' % (float(byte_counter) / float(data_len) * 100.0))
 132
 133     @staticmethod
 134     def calc_eta(start, now, total, current):
 135         if total is None:
 136             return '--:--'
 137         dif = now - start
 138         if current == 0 or dif < 0.001: # One millisecond
 139             return '--:--'
 140         rate = float(current) / dif
 141         eta = int((float(total) - float(current)) / rate)
 142         (eta_mins, eta_secs) = divmod(eta, 60)
 143         if eta_mins > 99:
 144             return '--:--'
 145         return '%02d:%02d' % (eta_mins, eta_secs)
 146
 147     @staticmethod
 148     def calc_speed(start, now, bytes):
 149         dif = now - start
 150         if bytes == 0 or dif < 0.001: # One millisecond
 151             return '%10s' % '---b/s'
 152         return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
 153
 154     @staticmethod
 155     def best_block_size(elapsed_time, bytes):
 156         new_min = max(bytes / 2.0, 1.0)
 157         new_max = min(max(bytes * 2.0, 1.0), 4194304) # Do not surpass 4 MB
 158         if elapsed_time < 0.001:
 159             return int(new_max)
 160         rate = bytes / elapsed_time
 161         if rate > new_max:
 162             return int(new_max)
 163         if rate < new_min:
 164             return int(new_min)
 165         return int(rate)
 166
 167     @staticmethod
 168     def parse_bytes(bytestr):
 169         """Parse a string indicating a byte quantity into an integer."""
 170         matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
 171         if matchobj is None:
 172             return None
 173         number = float(matchobj.group(1))
 174         multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
 175         return int(round(number * multiplier))
 176
 177     def add_info_extractor(self, ie):
 178         """Add an InfoExtractor object to the end of the list."""
 179         self._ies.append(ie)
 180         ie.set_downloader(self)
 181
 182     def add_post_processor(self, pp):
 183         """Add a PostProcessor object to the end of the chain."""
 184         self._pps.append(pp)
 185         pp.set_downloader(self)
 186
 187     def to_screen(self, message, skip_eol=False):
 188         """Print message to stdout if not in quiet mode."""
 189         assert type(message) == type(u'')
 190         if not self.params.get('quiet', False):
 191             terminator = [u'\n', u''][skip_eol]
 192             output = message + terminator
 193             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
 194                 output = output.encode(preferredencoding(), 'ignore')
 195             self._screen_file.write(output)
 196             self._screen_file.flush()
 197
 198     def to_stderr(self, message):
 199         """Print message to stderr."""
 200         assert type(message) == type(u'')
 201         output = message + u'\n'
 202         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
 203             output = output.encode(preferredencoding())
 204         sys.stderr.write(output)
 205
 206     def to_cons_title(self, message):
 207         """Set console/terminal window title to message."""
 208         if not self.params.get('consoletitle', False):
 209             return
 210         if os.name == 'nt' and ctypes.windll.kernel32.GetConsoleWindow():
 211             # c_wchar_p() might not be necessary if `message` is
 212             # already of type unicode()
 213             ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
 214         elif 'TERM' in os.environ:
 215             self.to_screen('\033]0;%s\007' % message, skip_eol=True)
 216
 217     def fixed_template(self):
 218         """Checks if the output template is fixed."""
 219         return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
 220
 221     def trouble(self, message=None, tb=None):
 222         """Determine action to take when a download problem appears.
 223
 224         Depending on if the downloader has been configured to ignore
 225         download errors or not, this method may throw an exception or
 226         not when errors are found, after printing the message.
 227
 228         tb, if given, is additional traceback information.
 229         """
 230         if message is not None:
 231             self.to_stderr(message)
 232         if self.params.get('verbose'):
 233             if tb is None:
 234                 if sys.exc_info()[0]:  # if .trouble has been called from an except block
 235                     tb = u''
 236                     if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 237                         tb += u''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
 238                     tb += compat_str(traceback.format_exc())
 239                 else:
 240                     tb_data = traceback.format_list(traceback.extract_stack())
 241                     tb = u''.join(tb_data)
 242             self.to_stderr(tb)
 243         if not self.params.get('ignoreerrors', False):
 244             if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
 245                 exc_info = sys.exc_info()[1].exc_info
 246             else:
 247                 exc_info = sys.exc_info()
 248             raise DownloadError(message, exc_info)
 249         self._download_retcode = 1
 250
 251     def report_warning(self, message):
 252         '''
 253         Print the message to stderr, it will be prefixed with 'WARNING:'
 254         If stderr is a tty file the 'WARNING:' will be colored
 255         '''
 256         if sys.stderr.isatty():
 257             _msg_header=u'\033[0;33mWARNING:\033[0m'
 258         else:
 259             _msg_header=u'WARNING:'
 260         warning_message=u'%s %s' % (_msg_header,message)
 261         self.to_stderr(warning_message)
 262
 263     def report_error(self, message, tb=None):
 264         '''
 265         Do the same as trouble, but prefixes the message with 'ERROR:', colored
 266         in red if stderr is a tty file.
 267         '''
 268         if sys.stderr.isatty():
 269             _msg_header = u'\033[0;31mERROR:\033[0m'
 270         else:
 271             _msg_header = u'ERROR:'
 272         error_message = u'%s %s' % (_msg_header, message)
 273         self.trouble(error_message, tb)
 274
 275     def slow_down(self, start_time, byte_counter):
 276         """Sleep if the download speed is over the rate limit."""
 277         rate_limit = self.params.get('ratelimit', None)
 278         if rate_limit is None or byte_counter == 0:
 279             return
 280         now = time.time()
 281         elapsed = now - start_time
 282         if elapsed <= 0.0:
 283             return
 284         speed = float(byte_counter) / elapsed
 285         if speed > rate_limit:
 286             time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
 287
 288     def temp_name(self, filename):
 289         """Returns a temporary filename for the given filename."""
 290         if self.params.get('nopart', False) or filename == u'-' or \
 291                 (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):
 292             return filename
 293         return filename + u'.part'
 294
 295     def undo_temp_name(self, filename):
 296         if filename.endswith(u'.part'):
 297             return filename[:-len(u'.part')]
 298         return filename
 299
 300     def try_rename(self, old_filename, new_filename):
 301         try:
 302             if old_filename == new_filename:
 303                 return
 304             os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
 305         except (IOError, OSError) as err:
 306             self.report_error(u'unable to rename file')
 307
 308     def try_utime(self, filename, last_modified_hdr):
 309         """Try to set the last-modified time of the given file."""
 310         if last_modified_hdr is None:
 311             return
 312         if not os.path.isfile(encodeFilename(filename)):
 313             return
 314         timestr = last_modified_hdr
 315         if timestr is None:
 316             return
 317         filetime = timeconvert(timestr)
 318         if filetime is None:
 319             return filetime
 320         try:
 321             os.utime(filename, (time.time(), filetime))
 322         except:
 323             pass
 324         return filetime
 325
 326     def report_writedescription(self, descfn):
 327         """ Report that the description file is being written """
 328         self.to_screen(u'[info] Writing video description to: ' + descfn)
 329
 330     def report_writesubtitles(self, sub_filename):
 331         """ Report that the subtitles file is being written """
 332         self.to_screen(u'[info] Writing video subtitles to: ' + sub_filename)
 333
 334     def report_writeinfojson(self, infofn):
 335         """ Report that the metadata file has been written """
 336         self.to_screen(u'[info] Video description metadata as JSON to: ' + infofn)
 337
 338     def report_destination(self, filename):
 339         """Report destination filename."""
 340         self.to_screen(u'[download] Destination: ' + filename)
 341
 342     def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
 343         """Report download progress."""
 344         if self.params.get('noprogress', False):
 345             return
 346         if self.params.get('progress_with_newline', False):
 347             self.to_screen(u'[download] %s of %s at %s ETA %s' %
 348                 (percent_str, data_len_str, speed_str, eta_str))
 349         else:
 350             self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
 351                 (percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
 352         self.to_cons_title(u'youtube-dl - %s of %s at %s ETA %s' %
 353                 (percent_str.strip(), data_len_str.strip(), speed_str.strip(), eta_str.strip()))
 354
 355     def report_resuming_byte(self, resume_len):
 356         """Report attempt to resume at given byte."""
 357         self.to_screen(u'[download] Resuming download at byte %s' % resume_len)
 358
 359     def report_retry(self, count, retries):
 360         """Report retry in case of HTTP error 5xx"""
 361         self.to_screen(u'[download] Got server HTTP error. Retrying (attempt %d of %d)...' % (count, retries))
 362
 363     def report_file_already_downloaded(self, file_name):
 364         """Report file has already been fully downloaded."""
 365         try:
 366             self.to_screen(u'[download] %s has already been downloaded' % file_name)
 367         except (UnicodeEncodeError) as err:
 368             self.to_screen(u'[download] The file has already been downloaded')
 369
 370     def report_unable_to_resume(self):
 371         """Report it was impossible to resume download."""
 372         self.to_screen(u'[download] Unable to resume')
 373
 374     def report_finish(self):
 375         """Report download finished."""
 376         if self.params.get('noprogress', False):
 377             self.to_screen(u'[download] Download completed')
 378         else:
 379             self.to_screen(u'')
 380
 381     def increment_downloads(self):
 382         """Increment the ordinal that assigns a number to each file."""
 383         self._num_downloads += 1
 384
 385     def prepare_filename(self, info_dict):
 386         """Generate the output filename."""
 387         try:
 388             template_dict = dict(info_dict)
 389
 390             template_dict['epoch'] = int(time.time())
 391             template_dict['autonumber'] = u'%05d' % self._num_downloads
 392             if template_dict['playlist_index'] is not None:
 393                 template_dict['playlist_index'] = u'%05d' % template_dict['playlist_index']
 394
 395             sanitize = lambda k,v: sanitize_filename(
 396                 u'NA' if v is None else compat_str(v),
 397                 restricted=self.params.get('restrictfilenames'),
 398                 is_id=(k==u'id'))
 399             template_dict = dict((k, sanitize(k, v)) for k,v in template_dict.items())
 400
 401             filename = self.params['outtmpl'] % template_dict
 402             return filename
 403         except KeyError as err:
 404             self.trouble(u'ERROR: Erroneous output template')
 405             return None
 406         except ValueError as err:
 407             self.trouble(u'ERROR: Insufficient system charset ' + repr(preferredencoding()))
 408             return None
 409
 410     def _match_entry(self, info_dict):
 411         """ Returns None iff the file should be downloaded """
 412
 413         title = info_dict['title']
 414         matchtitle = self.params.get('matchtitle', False)
 415         if matchtitle:
 416             if not re.search(matchtitle, title, re.IGNORECASE):
 417                 return u'[download] "' + title + '" title did not match pattern "' + matchtitle + '"'
 418         rejecttitle = self.params.get('rejecttitle', False)
 419         if rejecttitle:
 420             if re.search(rejecttitle, title, re.IGNORECASE):
 421                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
 422         return None
 423
 424     def extract_info(self, url, download = True):
 425         '''
 426         Returns a list with a dictionary for each video we find.
 427         If 'download', also downloads the videos.
 428          '''
 429         suitable_found = False
 430         for ie in self._ies:
 431             # Go to next InfoExtractor if not suitable
 432             if not ie.suitable(url):
 433                 continue
 434
 435             # Warn if the _WORKING attribute is False
 436             if not ie.working():
 437                 self.to_stderr(u'WARNING: the program functionality for this site has been marked as broken, '
 438                                u'and will probably not work. If you want to go on, use the -i option.')
 439
 440             # Suitable InfoExtractor found
 441             suitable_found = True
 442
 443             # Extract information from URL and process it
 444             try:
 445                 ie_results = ie.extract(url)
 446                 results = []
 447                 for ie_result in ie_results:
 448                     if not 'extractor' in ie_result:
 449                         #The extractor has already been set somewhere else
 450                         ie_result['extractor'] = ie.IE_NAME
 451                     results.append(self.process_ie_result(ie_result, download))
 452                 return results
 453             except ExtractorError as de: # An error we somewhat expected
 454                 self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
 455                 break
 456             except Exception as e:
 457                 if self.params.get('ignoreerrors', False):
 458                     self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))
 459                     break
 460                 else:
 461                     raise
 462         if not suitable_found:
 463                 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
 464
 465     def process_ie_result(self, ie_result, download = True):
 466         """
 467         Take the result of the ie and return a list of videos.
 468         For url elements it will search the suitable ie and get the videos
 469         For playlist elements it will process each of the elements of the 'entries' key
 470
 471         It will also download the videos if 'download'.
 472         """
 473         result_type = ie_result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
 474         if result_type == 'video':
 475             if 'playlist' not in ie_result:
 476                 #It isn't part of a playlist
 477                 ie_result['playlist'] = None
 478                 ie_result['playlist_index'] = None
 479             if download:
 480                 #Do the download:
 481                 self.process_info(ie_result)
 482             return ie_result
 483         elif result_type == 'url':
 484             #We get the video pointed by the url
 485             result = self.extract_info(ie_result['url'], download)[0]
 486             return result
 487         elif result_type == 'playlist':
 488             #We process each entry in the playlist
 489             playlist = ie_result.get('title', None) or ie_result.get('id', None)
 490             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
 491
 492             playlist_results = []
 493
 494             n_all_entries = len(ie_result['entries'])
 495             playliststart = self.params.get('playliststart', 1) - 1
 496             playlistend = self.params.get('playlistend', -1)
 497
 498             if playlistend == -1:
 499                 entries = ie_result['entries'][playliststart:]
 500             else:
 501                 entries = ie_result['entries'][playliststart:playlistend]
 502
 503             n_entries = len(entries)
 504
 505             self.to_screen(u"[%s] playlist '%s': Collected %d video ids (downloading %d of them)" %
 506                 (ie_result['extractor'], playlist, n_all_entries, n_entries))
 507
 508             for i,entry in enumerate(entries,1):
 509                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
 510                 entry_result = self.process_ie_result(entry, False)
 511                 entry_result['playlist'] = playlist
 512                 entry_result['playlist_index'] = i + playliststart
 513                 #We must do the download here to correctly set the 'playlist' key
 514                 if download:
 515                     self.process_info(entry_result)
 516                 playlist_results.append(entry_result)
 517             result = ie_result.copy()
 518             result['entries'] = playlist_results
 519             return result
 520
 521     def process_info(self, info_dict):
 522         """Process a single dictionary returned by an InfoExtractor."""
 523
 524         #We increment the download the download count here to match the previous behaviour.
 525         self.increment_downloads()
 526
 527         # Keep for backwards compatibility
 528         info_dict['stitle'] = info_dict['title']
 529
 530         if not 'format' in info_dict:
 531             info_dict['format'] = info_dict['ext']
 532
 533         reason = self._match_entry(info_dict)
 534         if reason is not None:
 535             self.to_screen(u'[download] ' + reason)
 536             return
 537
 538         max_downloads = self.params.get('max_downloads')
 539         if max_downloads is not None:
 540             if self._num_downloads > int(max_downloads):
 541                 raise MaxDownloadsReached()
 542
 543         filename = self.prepare_filename(info_dict)
 544
 545         # Forced printings
 546         if self.params.get('forcetitle', False):
 547             compat_print(info_dict['title'])
 548         if self.params.get('forceurl', False):
 549             compat_print(info_dict['url'])
 550         if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
 551             compat_print(info_dict['thumbnail'])
 552         if self.params.get('forcedescription', False) and 'description' in info_dict:
 553             compat_print(info_dict['description'])
 554         if self.params.get('forcefilename', False) and filename is not None:
 555             compat_print(filename)
 556         if self.params.get('forceformat', False):
 557             compat_print(info_dict['format'])
 558
 559         # Do nothing else if in simulate mode
 560         if self.params.get('simulate', False):
 561             return
 562
 563         if filename is None:
 564             return
 565
 566         try:
 567             dn = os.path.dirname(encodeFilename(filename))
 568             if dn != '' and not os.path.exists(dn): # dn is already encoded
 569                 os.makedirs(dn)
 570         except (OSError, IOError) as err:
 571             self.report_error(u'unable to create directory ' + compat_str(err))
 572             return
 573
 574         if self.params.get('writedescription', False):
 575             try:
 576                 descfn = filename + u'.description'
 577                 self.report_writedescription(descfn)
 578                 with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
 579                     descfile.write(info_dict['description'])
 580             except (OSError, IOError):
 581                 self.report_error(u'Cannot write description file ' + descfn)
 582                 return
 583
 584         if self.params.get('writesubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
 585             # subtitles download errors are already managed as troubles in relevant IE
 586             # that way it will silently go on when used with unsupporting IE
 587             subtitle = info_dict['subtitles'][0]
 588             (sub_error, sub_lang, sub) = subtitle
 589             sub_format = self.params.get('subtitlesformat')
 590             if sub_error:
 591                 self.report_warning("Some error while getting the subtitles")
 592             else:
 593                 try:
 594                     sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
 595                     self.report_writesubtitles(sub_filename)
 596                     with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
 597                         subfile.write(sub)
 598                 except (OSError, IOError):
 599                     self.report_error(u'Cannot write subtitles file ' + descfn)
 600                     return
 601             if self.params.get('onlysubtitles', False):
 602                 return
 603
 604         if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
 605             subtitles = info_dict['subtitles']
 606             sub_format = self.params.get('subtitlesformat')
 607             for subtitle in subtitles:
 608                 (sub_error, sub_lang, sub) = subtitle
 609                 if sub_error:
 610                     self.report_warning("Some error while getting the subtitles")
 611                 else:
 612                     try:
 613                         sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
 614                         self.report_writesubtitles(sub_filename)
 615                         with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
 616                                 subfile.write(sub)
 617                     except (OSError, IOError):
 618                         self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
 619                         return
 620             if self.params.get('onlysubtitles', False):
 621                 return
 622
 623         if self.params.get('writeinfojson', False):
 624             infofn = filename + u'.info.json'
 625             self.report_writeinfojson(infofn)
 626             try:
 627                 json_info_dict = dict((k, v) for k,v in info_dict.items() if not k in ['urlhandle'])
 628                 write_json_file(json_info_dict, encodeFilename(infofn))
 629             except (OSError, IOError):
 630                 self.report_error(u'Cannot write metadata to JSON file ' + infofn)
 631                 return
 632
 633         if not self.params.get('skip_download', False):
 634             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
 635                 success = True
 636             else:
 637                 try:
 638                     success = self._do_download(filename, info_dict)
 639                 except (OSError, IOError) as err:
 640                     raise UnavailableVideoError()
 641                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 642                     self.report_error(u'unable to download video data: %s' % str(err))
 643                     return
 644                 except (ContentTooShortError, ) as err:
 645                     self.report_error(u'content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
 646                     return
 647
 648             if success:
 649                 try:
 650                     self.post_process(filename, info_dict)
 651                 except (PostProcessingError) as err:
 652                     self.report_error(u'postprocessing: %s' % str(err))
 653                     return
 654
 655     def download(self, url_list):
 656         """Download a given list of URLs."""
 657         if len(url_list) > 1 and self.fixed_template():
 658             raise SameFileError(self.params['outtmpl'])
 659
 660         for url in url_list:
 661             try:
 662                 #It also downloads the videos
 663                 videos = self.extract_info(url)
 664             except UnavailableVideoError:
 665                 self.trouble(u'\nERROR: unable to download video')
 666             except MaxDownloadsReached:
 667                 self.to_screen(u'[info] Maximum number of downloaded files reached.')
 668                 raise
 669
 670         return self._download_retcode
 671
 672     def post_process(self, filename, ie_info):
 673         """Run all the postprocessors on the given file."""
 674         info = dict(ie_info)
 675         info['filepath'] = filename
 676         keep_video = None
 677         for pp in self._pps:
 678             try:
 679                 keep_video_wish,new_info = pp.run(info)
 680                 if keep_video_wish is not None:
 681                     if keep_video_wish:
 682                         keep_video = keep_video_wish
 683                     elif keep_video is None:
 684                         # No clear decision yet, let IE decide
 685                         keep_video = keep_video_wish
 686             except PostProcessingError as e:
 687                 self.to_stderr(u'ERROR: ' + e.msg)
 688         if keep_video is False and not self.params.get('keepvideo', False):
 689             try:
 690                 self.to_screen(u'Deleting original file %s (pass -k to keep)' % filename)
 691                 os.remove(encodeFilename(filename))
 692             except (IOError, OSError):
 693                 self.report_warning(u'Unable to remove downloaded video file')
 694
 695     def _download_with_rtmpdump(self, filename, url, player_url, page_url):
 696         self.report_destination(filename)
 697         tmpfilename = self.temp_name(filename)
 698
 699         # Check for rtmpdump first
 700         try:
 701             subprocess.call(['rtmpdump', '-h'], stdout=(open(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
 702         except (OSError, IOError):
 703             self.report_error(u'RTMP download detected but "rtmpdump" could not be run')
 704             return False
 705
 706         # Download using rtmpdump. rtmpdump returns exit code 2 when
 707         # the connection was interrumpted and resuming appears to be
 708         # possible. This is part of rtmpdump's normal usage, AFAIK.
 709         basic_args = ['rtmpdump', '-q', '-r', url, '-o', tmpfilename]
 710         if player_url is not None:
 711             basic_args += ['-W', player_url]
 712         if page_url is not None:
 713             basic_args += ['--pageUrl', page_url]
 714         args = basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)]
 715         if self.params.get('verbose', False):
 716             try:
 717                 import pipes
 718                 shell_quote = lambda args: ' '.join(map(pipes.quote, args))
 719             except ImportError:
 720                 shell_quote = repr
 721             self.to_screen(u'[debug] rtmpdump command line: ' + shell_quote(args))
 722         retval = subprocess.call(args)
 723         while retval == 2 or retval == 1:
 724             prevsize = os.path.getsize(encodeFilename(tmpfilename))
 725             self.to_screen(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
 726             time.sleep(5.0) # This seems to be needed
 727             retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval == 1])
 728             cursize = os.path.getsize(encodeFilename(tmpfilename))
 729             if prevsize == cursize and retval == 1:
 730                 break
 731              # Some rtmp streams seem abort after ~ 99.8%. Don't complain for those
 732             if prevsize == cursize and retval == 2 and cursize > 1024:
 733                 self.to_screen(u'\r[rtmpdump] Could not download the whole video. This can happen for some advertisements.')
 734                 retval = 0
 735                 break
 736         if retval == 0:
 737             fsize = os.path.getsize(encodeFilename(tmpfilename))
 738             self.to_screen(u'\r[rtmpdump] %s bytes' % fsize)
 739             self.try_rename(tmpfilename, filename)
 740             self._hook_progress({
 741                 'downloaded_bytes': fsize,
 742                 'total_bytes': fsize,
 743                 'filename': filename,
 744                 'status': 'finished',
 745             })
 746             return True
 747         else:
 748             self.to_stderr(u"\n")
 749             self.report_error(u'rtmpdump exited with code %d' % retval)
 750             return False
 751
 752     def _do_download(self, filename, info_dict):
 753         url = info_dict['url']
 754
 755         # Check file already present
 756         if self.params.get('continuedl', False) and os.path.isfile(encodeFilename(filename)) and not self.params.get('nopart', False):
 757             self.report_file_already_downloaded(filename)
 758             self._hook_progress({
 759                 'filename': filename,
 760                 'status': 'finished',
 761             })
 762             return True
 763
 764         # Attempt to download using rtmpdump
 765         if url.startswith('rtmp'):
 766             return self._download_with_rtmpdump(filename, url,
 767                                                 info_dict.get('player_url', None),
 768                                                 info_dict.get('page_url', None))
 769
 770         tmpfilename = self.temp_name(filename)
 771         stream = None
 772
 773         # Do not include the Accept-Encoding header
 774         headers = {'Youtubedl-no-compression': 'True'}
 775         if 'user_agent' in info_dict:
 776             headers['Youtubedl-user-agent'] = info_dict['user_agent']
 777         basic_request = compat_urllib_request.Request(url, None, headers)
 778         request = compat_urllib_request.Request(url, None, headers)
 779
 780         if self.params.get('test', False):
 781             request.add_header('Range','bytes=0-10240')
 782
 783         # Establish possible resume length
 784         if os.path.isfile(encodeFilename(tmpfilename)):
 785             resume_len = os.path.getsize(encodeFilename(tmpfilename))
 786         else:
 787             resume_len = 0
 788
 789         open_mode = 'wb'
 790         if resume_len != 0:
 791             if self.params.get('continuedl', False):
 792                 self.report_resuming_byte(resume_len)
 793                 request.add_header('Range','bytes=%d-' % resume_len)
 794                 open_mode = 'ab'
 795             else:
 796                 resume_len = 0
 797
 798         count = 0
 799         retries = self.params.get('retries', 0)
 800         while count <= retries:
 801             # Establish connection
 802             try:
 803                 if count == 0 and 'urlhandle' in info_dict:
 804                     data = info_dict['urlhandle']
 805                 data = compat_urllib_request.urlopen(request)
 806                 break
 807             except (compat_urllib_error.HTTPError, ) as err:
 808                 if (err.code < 500 or err.code >= 600) and err.code != 416:
 809                     # Unexpected HTTP error
 810                     raise
 811                 elif err.code == 416:
 812                     # Unable to resume (requested range not satisfiable)
 813                     try:
 814                         # Open the connection again without the range header
 815                         data = compat_urllib_request.urlopen(basic_request)
 816                         content_length = data.info()['Content-Length']
 817                     except (compat_urllib_error.HTTPError, ) as err:
 818                         if err.code < 500 or err.code >= 600:
 819                             raise
 820                     else:
 821                         # Examine the reported length
 822                         if (content_length is not None and
 823                                 (resume_len - 100 < int(content_length) < resume_len + 100)):
 824                             # The file had already been fully downloaded.
 825                             # Explanation to the above condition: in issue #175 it was revealed that
 826                             # YouTube sometimes adds or removes a few bytes from the end of the file,
 827                             # changing the file size slightly and causing problems for some users. So
 828                             # I decided to implement a suggested change and consider the file
 829                             # completely downloaded if the file size differs less than 100 bytes from
 830                             # the one in the hard drive.
 831                             self.report_file_already_downloaded(filename)
 832                             self.try_rename(tmpfilename, filename)
 833                             self._hook_progress({
 834                                 'filename': filename,
 835                                 'status': 'finished',
 836                             })
 837                             return True
 838                         else:
 839                             # The length does not match, we start the download over
 840                             self.report_unable_to_resume()
 841                             open_mode = 'wb'
 842                             break
 843             # Retry
 844             count += 1
 845             if count <= retries:
 846                 self.report_retry(count, retries)
 847
 848         if count > retries:
 849             self.report_error(u'giving up after %s retries' % retries)
 850             return False
 851
 852         data_len = data.info().get('Content-length', None)
 853         if data_len is not None:
 854             data_len = int(data_len) + resume_len
 855             min_data_len = self.params.get("min_filesize", None)
 856             max_data_len =  self.params.get("max_filesize", None)
 857             if min_data_len is not None and data_len < min_data_len:
 858                 self.to_screen(u'\r[download] File is smaller than min-filesize (%s bytes < %s bytes). Aborting.' % (data_len, min_data_len))
 859                 return False
 860             if max_data_len is not None and data_len > max_data_len:
 861                 self.to_screen(u'\r[download] File is larger than max-filesize (%s bytes > %s bytes). Aborting.' % (data_len, max_data_len))
 862                 return False
 863
 864         data_len_str = self.format_bytes(data_len)
 865         byte_counter = 0 + resume_len
 866         block_size = self.params.get('buffersize', 1024)
 867         start = time.time()
 868         while True:
 869             # Download and write
 870             before = time.time()
 871             data_block = data.read(block_size)
 872             after = time.time()
 873             if len(data_block) == 0:
 874                 break
 875             byte_counter += len(data_block)
 876
 877             # Open file just in time
 878             if stream is None:
 879                 try:
 880                     (stream, tmpfilename) = sanitize_open(tmpfilename, open_mode)
 881                     assert stream is not None
 882                     filename = self.undo_temp_name(tmpfilename)
 883                     self.report_destination(filename)
 884                 except (OSError, IOError) as err:
 885                     self.report_error(u'unable to open for writing: %s' % str(err))
 886                     return False
 887             try:
 888                 stream.write(data_block)
 889             except (IOError, OSError) as err:
 890                 self.to_stderr(u"\n")
 891                 self.report_error(u'unable to write data: %s' % str(err))
 892                 return False
 893             if not self.params.get('noresizebuffer', False):
 894                 block_size = self.best_block_size(after - before, len(data_block))
 895
 896             # Progress message
 897             speed_str = self.calc_speed(start, time.time(), byte_counter - resume_len)
 898             if data_len is None:
 899                 self.report_progress('Unknown %', data_len_str, speed_str, 'Unknown ETA')
 900             else:
 901                 percent_str = self.calc_percent(byte_counter, data_len)
 902                 eta_str = self.calc_eta(start, time.time(), data_len - resume_len, byte_counter - resume_len)
 903                 self.report_progress(percent_str, data_len_str, speed_str, eta_str)
 904
 905             self._hook_progress({
 906                 'downloaded_bytes': byte_counter,
 907                 'total_bytes': data_len,
 908                 'tmpfilename': tmpfilename,
 909                 'filename': filename,
 910                 'status': 'downloading',
 911             })
 912
 913             # Apply rate limit
 914             self.slow_down(start, byte_counter - resume_len)
 915
 916         if stream is None:
 917             self.to_stderr(u"\n")
 918             self.report_error(u'Did not get any data blocks')
 919             return False
 920         stream.close()
 921         self.report_finish()
 922         if data_len is not None and byte_counter != data_len:
 923             raise ContentTooShortError(byte_counter, int(data_len))
 924         self.try_rename(tmpfilename, filename)
 925
 926         # Update file modification time
 927         if self.params.get('updatetime', True):
 928             info_dict['filetime'] = self.try_utime(filename, data.info().get('last-modified', None))
 929
 930         self._hook_progress({
 931             'downloaded_bytes': byte_counter,
 932             'total_bytes': byte_counter,
 933             'filename': filename,
 934             'status': 'finished',
 935         })
 936
 937         return True
 938
 939     def _hook_progress(self, status):
 940         for ph in self._progress_hooks:
 941             ph(status)
 942
 943     def add_progress_hook(self, ph):
 944         """ ph gets called on download progress, with a dictionary with the entries
 945         * filename: The final filename
 946         * status: One of "downloading" and "finished"
 947
 948         It can also have some of the following entries:
 949
 950         * downloaded_bytes: Bytes on disks
 951         * total_bytes: Total bytes, None if unknown
 952         * tmpfilename: The filename we're currently writing to
 953
 954         Hooks are guaranteed to be called at least once (with status "finished")
 955         if the download is successful.
 956         """
 957         self._progress_hooks.append(ph)