]> Raphaƫl G. Git Repositories - youtubedl/blob - youtube_dl/FileDownloader.py
debian/README.source: Update my own instructions.
[youtubedl] / 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 os
8 import re
9 import socket
10 import subprocess
11 import sys
12 import time
13 import traceback
14
15 if os.name == 'nt':
16 import ctypes
17
18 from .utils import *
19
20
21 class FileDownloader(object):
22 """File Downloader class.
23
24 File downloader objects are the ones responsible of downloading the
25 actual video file and writing it to disk if the user has requested
26 it, among some other tasks. In most cases there should be one per
27 program. As, given a video URL, the downloader doesn't know how to
28 extract all the needed information, task that InfoExtractors do, it
29 has to pass the URL to one of them.
30
31 For this, file downloader objects have a method that allows
32 InfoExtractors to be registered in a given order. When it is passed
33 a URL, the file downloader handles it to the first InfoExtractor it
34 finds that reports being able to handle it. The InfoExtractor extracts
35 all the information about the video or videos the URL refers to, and
36 asks the FileDownloader to process the video information, possibly
37 downloading the video.
38
39 File downloaders accept a lot of parameters. In order not to saturate
40 the object constructor with arguments, it receives a dictionary of
41 options instead. These options are available through the params
42 attribute for the InfoExtractors to use. The FileDownloader also
43 registers itself as the downloader in charge for the InfoExtractors
44 that are added to it, so this is a "mutual registration".
45
46 Available options:
47
48 username: Username for authentication purposes.
49 password: Password for authentication purposes.
50 usenetrc: Use netrc for authentication instead.
51 quiet: Do not print messages to stdout.
52 forceurl: Force printing final URL.
53 forcetitle: Force printing title.
54 forcethumbnail: Force printing thumbnail URL.
55 forcedescription: Force printing description.
56 forcefilename: Force printing final filename.
57 simulate: Do not download the video files.
58 format: Video format code.
59 format_limit: Highest quality format to try.
60 outtmpl: Template for output names.
61 restrictfilenames: Do not allow "&" and spaces in file names
62 ignoreerrors: Do not stop on download errors.
63 ratelimit: Download speed limit, in bytes/sec.
64 nooverwrites: Prevent overwriting files.
65 retries: Number of times to retry for HTTP error 5xx
66 buffersize: Size of download buffer in bytes.
67 noresizebuffer: Do not automatically resize the download buffer.
68 continuedl: Try to continue downloads if possible.
69 noprogress: Do not print the progress bar.
70 playliststart: Playlist item to start at.
71 playlistend: Playlist item to end at.
72 matchtitle: Download only matching titles.
73 rejecttitle: Reject downloads for matching titles.
74 logtostderr: Log messages to stderr instead of stdout.
75 consoletitle: Display progress in console window's titlebar.
76 nopart: Do not use temporary .part files.
77 updatetime: Use the Last-modified header to set output file timestamps.
78 writedescription: Write the video description to a .description file
79 writeinfojson: Write the video description to a .info.json file
80 writesubtitles: Write the video subtitles to a .srt file
81 subtitleslang: Language of the subtitles to download
82 test: Download only first bytes to test the downloader.
83 """
84
85 params = None
86 _ies = []
87 _pps = []
88 _download_retcode = None
89 _num_downloads = None
90 _screen_file = None
91
92 def __init__(self, params):
93 """Create a FileDownloader object with the given options."""
94 self._ies = []
95 self._pps = []
96 self._download_retcode = 0
97 self._num_downloads = 0
98 self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
99 self.params = params
100
101 if '%(stitle)s' in self.params['outtmpl']:
102 self.to_stderr(u'WARNING: %(stitle)s is deprecated. Use the %(title)s and the --restrict-filenames flag(which also secures %(uploader)s et al) instead.')
103
104 @staticmethod
105 def format_bytes(bytes):
106 if bytes is None:
107 return 'N/A'
108 if type(bytes) is str:
109 bytes = float(bytes)
110 if bytes == 0.0:
111 exponent = 0
112 else:
113 exponent = int(math.log(bytes, 1024.0))
114 suffix = 'bkMGTPEZY'[exponent]
115 converted = float(bytes) / float(1024 ** exponent)
116 return '%.2f%s' % (converted, suffix)
117
118 @staticmethod
119 def calc_percent(byte_counter, data_len):
120 if data_len is None:
121 return '---.-%'
122 return '%6s' % ('%3.1f%%' % (float(byte_counter) / float(data_len) * 100.0))
123
124 @staticmethod
125 def calc_eta(start, now, total, current):
126 if total is None:
127 return '--:--'
128 dif = now - start
129 if current == 0 or dif < 0.001: # One millisecond
130 return '--:--'
131 rate = float(current) / dif
132 eta = int((float(total) - float(current)) / rate)
133 (eta_mins, eta_secs) = divmod(eta, 60)
134 if eta_mins > 99:
135 return '--:--'
136 return '%02d:%02d' % (eta_mins, eta_secs)
137
138 @staticmethod
139 def calc_speed(start, now, bytes):
140 dif = now - start
141 if bytes == 0 or dif < 0.001: # One millisecond
142 return '%10s' % '---b/s'
143 return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
144
145 @staticmethod
146 def best_block_size(elapsed_time, bytes):
147 new_min = max(bytes / 2.0, 1.0)
148 new_max = min(max(bytes * 2.0, 1.0), 4194304) # Do not surpass 4 MB
149 if elapsed_time < 0.001:
150 return int(new_max)
151 rate = bytes / elapsed_time
152 if rate > new_max:
153 return int(new_max)
154 if rate < new_min:
155 return int(new_min)
156 return int(rate)
157
158 @staticmethod
159 def parse_bytes(bytestr):
160 """Parse a string indicating a byte quantity into an integer."""
161 matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
162 if matchobj is None:
163 return None
164 number = float(matchobj.group(1))
165 multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
166 return int(round(number * multiplier))
167
168 def add_info_extractor(self, ie):
169 """Add an InfoExtractor object to the end of the list."""
170 self._ies.append(ie)
171 ie.set_downloader(self)
172
173 def add_post_processor(self, pp):
174 """Add a PostProcessor object to the end of the chain."""
175 self._pps.append(pp)
176 pp.set_downloader(self)
177
178 def to_screen(self, message, skip_eol=False):
179 """Print message to stdout if not in quiet mode."""
180 assert type(message) == type(u'')
181 if not self.params.get('quiet', False):
182 terminator = [u'\n', u''][skip_eol]
183 output = message + terminator
184 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
185 output = output.encode(preferredencoding(), 'ignore')
186 self._screen_file.write(output)
187 self._screen_file.flush()
188
189 def to_stderr(self, message):
190 """Print message to stderr."""
191 assert type(message) == type(u'')
192 output = message + u'\n'
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())
195 sys.stderr.write(output)
196
197 def to_cons_title(self, message):
198 """Set console/terminal window title to message."""
199 if not self.params.get('consoletitle', False):
200 return
201 if os.name == 'nt' and ctypes.windll.kernel32.GetConsoleWindow():
202 # c_wchar_p() might not be necessary if `message` is
203 # already of type unicode()
204 ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
205 elif 'TERM' in os.environ:
206 sys.stderr.write('\033]0;%s\007' % message.encode(preferredencoding()))
207
208 def fixed_template(self):
209 """Checks if the output template is fixed."""
210 return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
211
212 def trouble(self, message=None):
213 """Determine action to take when a download problem appears.
214
215 Depending on if the downloader has been configured to ignore
216 download errors or not, this method may throw an exception or
217 not when errors are found, after printing the message.
218 """
219 if message is not None:
220 self.to_stderr(message)
221 if self.params.get('verbose'):
222 self.to_stderr(u''.join(traceback.format_list(traceback.extract_stack())))
223 if not self.params.get('ignoreerrors', False):
224 raise DownloadError(message)
225 self._download_retcode = 1
226
227 def slow_down(self, start_time, byte_counter):
228 """Sleep if the download speed is over the rate limit."""
229 rate_limit = self.params.get('ratelimit', None)
230 if rate_limit is None or byte_counter == 0:
231 return
232 now = time.time()
233 elapsed = now - start_time
234 if elapsed <= 0.0:
235 return
236 speed = float(byte_counter) / elapsed
237 if speed > rate_limit:
238 time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
239
240 def temp_name(self, filename):
241 """Returns a temporary filename for the given filename."""
242 if self.params.get('nopart', False) or filename == u'-' or \
243 (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):
244 return filename
245 return filename + u'.part'
246
247 def undo_temp_name(self, filename):
248 if filename.endswith(u'.part'):
249 return filename[:-len(u'.part')]
250 return filename
251
252 def try_rename(self, old_filename, new_filename):
253 try:
254 if old_filename == new_filename:
255 return
256 os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
257 except (IOError, OSError) as err:
258 self.trouble(u'ERROR: unable to rename file')
259
260 def try_utime(self, filename, last_modified_hdr):
261 """Try to set the last-modified time of the given file."""
262 if last_modified_hdr is None:
263 return
264 if not os.path.isfile(encodeFilename(filename)):
265 return
266 timestr = last_modified_hdr
267 if timestr is None:
268 return
269 filetime = timeconvert(timestr)
270 if filetime is None:
271 return filetime
272 try:
273 os.utime(filename, (time.time(), filetime))
274 except:
275 pass
276 return filetime
277
278 def report_writedescription(self, descfn):
279 """ Report that the description file is being written """
280 self.to_screen(u'[info] Writing video description to: ' + descfn)
281
282 def report_writesubtitles(self, srtfn):
283 """ Report that the subtitles file is being written """
284 self.to_screen(u'[info] Writing video subtitles to: ' + srtfn)
285
286 def report_writeinfojson(self, infofn):
287 """ Report that the metadata file has been written """
288 self.to_screen(u'[info] Video description metadata as JSON to: ' + infofn)
289
290 def report_destination(self, filename):
291 """Report destination filename."""
292 self.to_screen(u'[download] Destination: ' + filename)
293
294 def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
295 """Report download progress."""
296 if self.params.get('noprogress', False):
297 return
298 self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
299 (percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
300 self.to_cons_title(u'youtube-dl - %s of %s at %s ETA %s' %
301 (percent_str.strip(), data_len_str.strip(), speed_str.strip(), eta_str.strip()))
302
303 def report_resuming_byte(self, resume_len):
304 """Report attempt to resume at given byte."""
305 self.to_screen(u'[download] Resuming download at byte %s' % resume_len)
306
307 def report_retry(self, count, retries):
308 """Report retry in case of HTTP error 5xx"""
309 self.to_screen(u'[download] Got server HTTP error. Retrying (attempt %d of %d)...' % (count, retries))
310
311 def report_file_already_downloaded(self, file_name):
312 """Report file has already been fully downloaded."""
313 try:
314 self.to_screen(u'[download] %s has already been downloaded' % file_name)
315 except (UnicodeEncodeError) as err:
316 self.to_screen(u'[download] The file has already been downloaded')
317
318 def report_unable_to_resume(self):
319 """Report it was impossible to resume download."""
320 self.to_screen(u'[download] Unable to resume')
321
322 def report_finish(self):
323 """Report download finished."""
324 if self.params.get('noprogress', False):
325 self.to_screen(u'[download] Download completed')
326 else:
327 self.to_screen(u'')
328
329 def increment_downloads(self):
330 """Increment the ordinal that assigns a number to each file."""
331 self._num_downloads += 1
332
333 def prepare_filename(self, info_dict):
334 """Generate the output filename."""
335 try:
336 template_dict = dict(info_dict)
337
338 template_dict['epoch'] = int(time.time())
339 template_dict['autonumber'] = u'%05d' % self._num_downloads
340
341 sanitize = lambda k,v: sanitize_filename(
342 u'NA' if v is None else compat_str(v),
343 restricted=self.params.get('restrictfilenames'),
344 is_id=(k==u'id'))
345 template_dict = dict((k, sanitize(k, v)) for k,v in template_dict.items())
346
347 filename = self.params['outtmpl'] % template_dict
348 return filename
349 except (ValueError, KeyError) as err:
350 self.trouble(u'ERROR: invalid system charset or erroneous output template')
351 return None
352
353 def _match_entry(self, info_dict):
354 """ Returns None iff the file should be downloaded """
355
356 title = info_dict['title']
357 matchtitle = self.params.get('matchtitle', False)
358 if matchtitle:
359 matchtitle = matchtitle.decode('utf8')
360 if not re.search(matchtitle, title, re.IGNORECASE):
361 return u'[download] "' + title + '" title did not match pattern "' + matchtitle + '"'
362 rejecttitle = self.params.get('rejecttitle', False)
363 if rejecttitle:
364 rejecttitle = rejecttitle.decode('utf8')
365 if re.search(rejecttitle, title, re.IGNORECASE):
366 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
367 return None
368
369 def process_info(self, info_dict):
370 """Process a single dictionary returned by an InfoExtractor."""
371
372 # Keep for backwards compatibility
373 info_dict['stitle'] = info_dict['title']
374
375 if not 'format' in info_dict:
376 info_dict['format'] = info_dict['ext']
377
378 reason = self._match_entry(info_dict)
379 if reason is not None:
380 self.to_screen(u'[download] ' + reason)
381 return
382
383 max_downloads = self.params.get('max_downloads')
384 if max_downloads is not None:
385 if self._num_downloads > int(max_downloads):
386 raise MaxDownloadsReached()
387
388 filename = self.prepare_filename(info_dict)
389
390 # Forced printings
391 if self.params.get('forcetitle', False):
392 compat_print(info_dict['title'])
393 if self.params.get('forceurl', False):
394 compat_print(info_dict['url'])
395 if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
396 compat_print(info_dict['thumbnail'])
397 if self.params.get('forcedescription', False) and 'description' in info_dict:
398 compat_print(info_dict['description'])
399 if self.params.get('forcefilename', False) and filename is not None:
400 compat_print(filename)
401 if self.params.get('forceformat', False):
402 compat_print(info_dict['format'])
403
404 # Do nothing else if in simulate mode
405 if self.params.get('simulate', False):
406 return
407
408 if filename is None:
409 return
410
411 try:
412 dn = os.path.dirname(encodeFilename(filename))
413 if dn != '' and not os.path.exists(dn): # dn is already encoded
414 os.makedirs(dn)
415 except (OSError, IOError) as err:
416 self.trouble(u'ERROR: unable to create directory ' + compat_str(err))
417 return
418
419 if self.params.get('writedescription', False):
420 try:
421 descfn = filename + u'.description'
422 self.report_writedescription(descfn)
423 descfile = open(encodeFilename(descfn), 'wb')
424 try:
425 descfile.write(info_dict['description'].encode('utf-8'))
426 finally:
427 descfile.close()
428 except (OSError, IOError):
429 self.trouble(u'ERROR: Cannot write description file ' + descfn)
430 return
431
432 if self.params.get('writesubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
433 # subtitles download errors are already managed as troubles in relevant IE
434 # that way it will silently go on when used with unsupporting IE
435 try:
436 srtfn = filename.rsplit('.', 1)[0] + u'.srt'
437 self.report_writesubtitles(srtfn)
438 srtfile = open(encodeFilename(srtfn), 'wb')
439 try:
440 srtfile.write(info_dict['subtitles'].encode('utf-8'))
441 finally:
442 srtfile.close()
443 except (OSError, IOError):
444 self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
445 return
446
447 if self.params.get('writeinfojson', False):
448 infofn = filename + u'.info.json'
449 self.report_writeinfojson(infofn)
450 try:
451 json.dump
452 except (NameError,AttributeError):
453 self.trouble(u'ERROR: No JSON encoder found. Update to Python 2.6+, setup a json module, or leave out --write-info-json.')
454 return
455 try:
456 infof = open(encodeFilename(infofn), 'wb')
457 try:
458 json_info_dict = dict((k,v) for k,v in info_dict.iteritems() if not k in ('urlhandle',))
459 json.dump(json_info_dict, infof)
460 finally:
461 infof.close()
462 except (OSError, IOError):
463 self.trouble(u'ERROR: Cannot write metadata to JSON file ' + infofn)
464 return
465
466 if not self.params.get('skip_download', False):
467 if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
468 success = True
469 else:
470 try:
471 success = self._do_download(filename, info_dict)
472 except (OSError, IOError) as err:
473 raise UnavailableVideoError()
474 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
475 self.trouble(u'ERROR: unable to download video data: %s' % str(err))
476 return
477 except (ContentTooShortError, ) as err:
478 self.trouble(u'ERROR: content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
479 return
480
481 if success:
482 try:
483 self.post_process(filename, info_dict)
484 except (PostProcessingError) as err:
485 self.trouble(u'ERROR: postprocessing: %s' % str(err))
486 return
487
488 def download(self, url_list):
489 """Download a given list of URLs."""
490 if len(url_list) > 1 and self.fixed_template():
491 raise SameFileError(self.params['outtmpl'])
492
493 for url in url_list:
494 suitable_found = False
495 for ie in self._ies:
496 # Go to next InfoExtractor if not suitable
497 if not ie.suitable(url):
498 continue
499
500 # Warn if the _WORKING attribute is False
501 if not ie.working():
502 self.trouble(u'WARNING: the program functionality for this site has been marked as broken, '
503 u'and will probably not work. If you want to go on, use the -i option.')
504
505 # Suitable InfoExtractor found
506 suitable_found = True
507
508 # Extract information from URL and process it
509 videos = ie.extract(url)
510 for video in videos or []:
511 video['extractor'] = ie.IE_NAME
512 try:
513 self.increment_downloads()
514 self.process_info(video)
515 except UnavailableVideoError:
516 self.trouble(u'\nERROR: unable to download video')
517
518 # Suitable InfoExtractor had been found; go to next URL
519 break
520
521 if not suitable_found:
522 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
523
524 return self._download_retcode
525
526 def post_process(self, filename, ie_info):
527 """Run the postprocessing chain on the given file."""
528 info = dict(ie_info)
529 info['filepath'] = filename
530 for pp in self._pps:
531 info = pp.run(info)
532 if info is None:
533 break
534
535 def _download_with_rtmpdump(self, filename, url, player_url):
536 self.report_destination(filename)
537 tmpfilename = self.temp_name(filename)
538
539 # Check for rtmpdump first
540 try:
541 subprocess.call(['rtmpdump', '-h'], stdout=(file(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
542 except (OSError, IOError):
543 self.trouble(u'ERROR: RTMP download detected but "rtmpdump" could not be run')
544 return False
545
546 # Download using rtmpdump. rtmpdump returns exit code 2 when
547 # the connection was interrumpted and resuming appears to be
548 # possible. This is part of rtmpdump's normal usage, AFAIK.
549 basic_args = ['rtmpdump', '-q'] + [[], ['-W', player_url]][player_url is not None] + ['-r', url, '-o', tmpfilename]
550 args = basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)]
551 if self.params.get('verbose', False):
552 try:
553 import pipes
554 shell_quote = lambda args: ' '.join(map(pipes.quote, args))
555 except ImportError:
556 shell_quote = repr
557 self.to_screen(u'[debug] rtmpdump command line: ' + shell_quote(args))
558 retval = subprocess.call(args)
559 while retval == 2 or retval == 1:
560 prevsize = os.path.getsize(encodeFilename(tmpfilename))
561 self.to_screen(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
562 time.sleep(5.0) # This seems to be needed
563 retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval == 1])
564 cursize = os.path.getsize(encodeFilename(tmpfilename))
565 if prevsize == cursize and retval == 1:
566 break
567 # Some rtmp streams seem abort after ~ 99.8%. Don't complain for those
568 if prevsize == cursize and retval == 2 and cursize > 1024:
569 self.to_screen(u'\r[rtmpdump] Could not download the whole video. This can happen for some advertisements.')
570 retval = 0
571 break
572 if retval == 0:
573 self.to_screen(u'\r[rtmpdump] %s bytes' % os.path.getsize(encodeFilename(tmpfilename)))
574 self.try_rename(tmpfilename, filename)
575 return True
576 else:
577 self.trouble(u'\nERROR: rtmpdump exited with code %d' % retval)
578 return False
579
580 def _do_download(self, filename, info_dict):
581 url = info_dict['url']
582 player_url = info_dict.get('player_url', None)
583
584 # Check file already present
585 if self.params.get('continuedl', False) and os.path.isfile(encodeFilename(filename)) and not self.params.get('nopart', False):
586 self.report_file_already_downloaded(filename)
587 return True
588
589 # Attempt to download using rtmpdump
590 if url.startswith('rtmp'):
591 return self._download_with_rtmpdump(filename, url, player_url)
592
593 tmpfilename = self.temp_name(filename)
594 stream = None
595
596 # Do not include the Accept-Encoding header
597 headers = {'Youtubedl-no-compression': 'True'}
598 basic_request = compat_urllib_request.Request(url, None, headers)
599 request = compat_urllib_request.Request(url, None, headers)
600
601 if self.params.get('test', False):
602 request.add_header('Range','bytes=0-10240')
603
604 # Establish possible resume length
605 if os.path.isfile(encodeFilename(tmpfilename)):
606 resume_len = os.path.getsize(encodeFilename(tmpfilename))
607 else:
608 resume_len = 0
609
610 open_mode = 'wb'
611 if resume_len != 0:
612 if self.params.get('continuedl', False):
613 self.report_resuming_byte(resume_len)
614 request.add_header('Range','bytes=%d-' % resume_len)
615 open_mode = 'ab'
616 else:
617 resume_len = 0
618
619 count = 0
620 retries = self.params.get('retries', 0)
621 while count <= retries:
622 # Establish connection
623 try:
624 if count == 0 and 'urlhandle' in info_dict:
625 data = info_dict['urlhandle']
626 data = compat_urllib_request.urlopen(request)
627 break
628 except (compat_urllib_error.HTTPError, ) as err:
629 if (err.code < 500 or err.code >= 600) and err.code != 416:
630 # Unexpected HTTP error
631 raise
632 elif err.code == 416:
633 # Unable to resume (requested range not satisfiable)
634 try:
635 # Open the connection again without the range header
636 data = compat_urllib_request.urlopen(basic_request)
637 content_length = data.info()['Content-Length']
638 except (compat_urllib_error.HTTPError, ) as err:
639 if err.code < 500 or err.code >= 600:
640 raise
641 else:
642 # Examine the reported length
643 if (content_length is not None and
644 (resume_len - 100 < int(content_length) < resume_len + 100)):
645 # The file had already been fully downloaded.
646 # Explanation to the above condition: in issue #175 it was revealed that
647 # YouTube sometimes adds or removes a few bytes from the end of the file,
648 # changing the file size slightly and causing problems for some users. So
649 # I decided to implement a suggested change and consider the file
650 # completely downloaded if the file size differs less than 100 bytes from
651 # the one in the hard drive.
652 self.report_file_already_downloaded(filename)
653 self.try_rename(tmpfilename, filename)
654 return True
655 else:
656 # The length does not match, we start the download over
657 self.report_unable_to_resume()
658 open_mode = 'wb'
659 break
660 # Retry
661 count += 1
662 if count <= retries:
663 self.report_retry(count, retries)
664
665 if count > retries:
666 self.trouble(u'ERROR: giving up after %s retries' % retries)
667 return False
668
669 data_len = data.info().get('Content-length', None)
670 if data_len is not None:
671 data_len = int(data_len) + resume_len
672 data_len_str = self.format_bytes(data_len)
673 byte_counter = 0 + resume_len
674 block_size = self.params.get('buffersize', 1024)
675 start = time.time()
676 while True:
677 # Download and write
678 before = time.time()
679 data_block = data.read(block_size)
680 after = time.time()
681 if len(data_block) == 0:
682 break
683 byte_counter += len(data_block)
684
685 # Open file just in time
686 if stream is None:
687 try:
688 (stream, tmpfilename) = sanitize_open(tmpfilename, open_mode)
689 assert stream is not None
690 filename = self.undo_temp_name(tmpfilename)
691 self.report_destination(filename)
692 except (OSError, IOError) as err:
693 self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
694 return False
695 try:
696 stream.write(data_block)
697 except (IOError, OSError) as err:
698 self.trouble(u'\nERROR: unable to write data: %s' % str(err))
699 return False
700 if not self.params.get('noresizebuffer', False):
701 block_size = self.best_block_size(after - before, len(data_block))
702
703 # Progress message
704 speed_str = self.calc_speed(start, time.time(), byte_counter - resume_len)
705 if data_len is None:
706 self.report_progress('Unknown %', data_len_str, speed_str, 'Unknown ETA')
707 else:
708 percent_str = self.calc_percent(byte_counter, data_len)
709 eta_str = self.calc_eta(start, time.time(), data_len - resume_len, byte_counter - resume_len)
710 self.report_progress(percent_str, data_len_str, speed_str, eta_str)
711
712 # Apply rate limit
713 self.slow_down(start, byte_counter - resume_len)
714
715 if stream is None:
716 self.trouble(u'\nERROR: Did not get any data blocks')
717 return False
718 stream.close()
719 self.report_finish()
720 if data_len is not None and byte_counter != data_len:
721 raise ContentTooShortError(byte_counter, int(data_len))
722 self.try_rename(tmpfilename, filename)
723
724 # Update file modification time
725 if self.params.get('updatetime', True):
726 info_dict['filetime'] = self.try_utime(filename, data.info().get('last-modified', None))
727
728 return True