]> git.bitcoin.ninja Git - youtube-dl/blob - downloader/common.py
[youtube] Fix extraction.
[youtube-dl] / downloader / common.py
1 from __future__ import division, unicode_literals
2
3 import os
4 import re
5 import sys
6 import time
7 import random
8
9 from ..compat import compat_os_name
10 from ..utils import (
11     decodeArgument,
12     encodeFilename,
13     error_to_compat_str,
14     format_bytes,
15     shell_quote,
16     timeconvert,
17 )
18
19
20 class FileDownloader(object):
21     """File Downloader class.
22
23     File downloader objects are the ones responsible of downloading the
24     actual video file and writing it to disk.
25
26     File downloaders accept a lot of parameters. In order not to saturate
27     the object constructor with arguments, it receives a dictionary of
28     options instead.
29
30     Available options:
31
32     verbose:            Print additional info to stdout.
33     quiet:              Do not print messages to stdout.
34     ratelimit:          Download speed limit, in bytes/sec.
35     retries:            Number of times to retry for HTTP error 5xx
36     buffersize:         Size of download buffer in bytes.
37     noresizebuffer:     Do not automatically resize the download buffer.
38     continuedl:         Try to continue downloads if possible.
39     noprogress:         Do not print the progress bar.
40     logtostderr:        Log messages to stderr instead of stdout.
41     consoletitle:       Display progress in console window's titlebar.
42     nopart:             Do not use temporary .part files.
43     updatetime:         Use the Last-modified header to set output file timestamps.
44     test:               Download only first bytes to test the downloader.
45     min_filesize:       Skip files smaller than this size
46     max_filesize:       Skip files larger than this size
47     xattr_set_filesize: Set ytdl.filesize user xattribute with expected size.
48     external_downloader_args:  A list of additional command-line arguments for the
49                         external downloader.
50     hls_use_mpegts:     Use the mpegts container for HLS videos.
51     http_chunk_size:    Size of a chunk for chunk-based HTTP downloading. May be
52                         useful for bypassing bandwidth throttling imposed by
53                         a webserver (experimental)
54
55     Subclasses of this one must re-define the real_download method.
56     """
57
58     _TEST_FILE_SIZE = 10241
59     params = None
60
61     def __init__(self, ydl, params):
62         """Create a FileDownloader object with the given options."""
63         self.ydl = ydl
64         self._progress_hooks = []
65         self.params = params
66         self.add_progress_hook(self.report_progress)
67
68     @staticmethod
69     def format_seconds(seconds):
70         (mins, secs) = divmod(seconds, 60)
71         (hours, mins) = divmod(mins, 60)
72         if hours > 99:
73             return '--:--:--'
74         if hours == 0:
75             return '%02d:%02d' % (mins, secs)
76         else:
77             return '%02d:%02d:%02d' % (hours, mins, secs)
78
79     @staticmethod
80     def calc_percent(byte_counter, data_len):
81         if data_len is None:
82             return None
83         return float(byte_counter) / float(data_len) * 100.0
84
85     @staticmethod
86     def format_percent(percent):
87         if percent is None:
88             return '---.-%'
89         return '%6s' % ('%3.1f%%' % percent)
90
91     @staticmethod
92     def calc_eta(start, now, total, current):
93         if total is None:
94             return None
95         if now is None:
96             now = time.time()
97         dif = now - start
98         if current == 0 or dif < 0.001:  # One millisecond
99             return None
100         rate = float(current) / dif
101         return int((float(total) - float(current)) / rate)
102
103     @staticmethod
104     def format_eta(eta):
105         if eta is None:
106             return '--:--'
107         return FileDownloader.format_seconds(eta)
108
109     @staticmethod
110     def calc_speed(start, now, bytes):
111         dif = now - start
112         if bytes == 0 or dif < 0.001:  # One millisecond
113             return None
114         return float(bytes) / dif
115
116     @staticmethod
117     def format_speed(speed):
118         if speed is None:
119             return '%10s' % '---b/s'
120         return '%10s' % ('%s/s' % format_bytes(speed))
121
122     @staticmethod
123     def format_retries(retries):
124         return 'inf' if retries == float('inf') else '%.0f' % retries
125
126     @staticmethod
127     def best_block_size(elapsed_time, bytes):
128         new_min = max(bytes / 2.0, 1.0)
129         new_max = min(max(bytes * 2.0, 1.0), 4194304)  # Do not surpass 4 MB
130         if elapsed_time < 0.001:
131             return int(new_max)
132         rate = bytes / elapsed_time
133         if rate > new_max:
134             return int(new_max)
135         if rate < new_min:
136             return int(new_min)
137         return int(rate)
138
139     @staticmethod
140     def parse_bytes(bytestr):
141         """Parse a string indicating a byte quantity into an integer."""
142         matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
143         if matchobj is None:
144             return None
145         number = float(matchobj.group(1))
146         multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
147         return int(round(number * multiplier))
148
149     def to_screen(self, *args, **kargs):
150         self.ydl.to_screen(*args, **kargs)
151
152     def to_stderr(self, message):
153         self.ydl.to_screen(message)
154
155     def to_console_title(self, message):
156         self.ydl.to_console_title(message)
157
158     def trouble(self, *args, **kargs):
159         self.ydl.trouble(*args, **kargs)
160
161     def report_warning(self, *args, **kargs):
162         self.ydl.report_warning(*args, **kargs)
163
164     def report_error(self, *args, **kargs):
165         self.ydl.report_error(*args, **kargs)
166
167     def slow_down(self, start_time, now, byte_counter):
168         """Sleep if the download speed is over the rate limit."""
169         rate_limit = self.params.get('ratelimit')
170         if rate_limit is None or byte_counter == 0:
171             return
172         if now is None:
173             now = time.time()
174         elapsed = now - start_time
175         if elapsed <= 0.0:
176             return
177         speed = float(byte_counter) / elapsed
178         if speed > rate_limit:
179             time.sleep(max((byte_counter // rate_limit) - elapsed, 0))
180
181     def temp_name(self, filename):
182         """Returns a temporary filename for the given filename."""
183         if self.params.get('nopart', False) or filename == '-' or \
184                 (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):
185             return filename
186         return filename + '.part'
187
188     def undo_temp_name(self, filename):
189         if filename.endswith('.part'):
190             return filename[:-len('.part')]
191         return filename
192
193     def ytdl_filename(self, filename):
194         return filename + '.ytdl'
195
196     def try_rename(self, old_filename, new_filename):
197         try:
198             if old_filename == new_filename:
199                 return
200             os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
201         except (IOError, OSError) as err:
202             self.report_error('unable to rename file: %s' % error_to_compat_str(err))
203
204     def try_utime(self, filename, last_modified_hdr):
205         """Try to set the last-modified time of the given file."""
206         if last_modified_hdr is None:
207             return
208         if not os.path.isfile(encodeFilename(filename)):
209             return
210         timestr = last_modified_hdr
211         if timestr is None:
212             return
213         filetime = timeconvert(timestr)
214         if filetime is None:
215             return filetime
216         # Ignore obviously invalid dates
217         if filetime == 0:
218             return
219         try:
220             os.utime(filename, (time.time(), filetime))
221         except Exception:
222             pass
223         return filetime
224
225     def report_destination(self, filename):
226         """Report destination filename."""
227         self.to_screen('[download] Destination: ' + filename)
228
229     def _report_progress_status(self, msg, is_last_line=False):
230         fullmsg = '[download] ' + msg
231         if self.params.get('progress_with_newline', False):
232             self.to_screen(fullmsg)
233         else:
234             if compat_os_name == 'nt':
235                 prev_len = getattr(self, '_report_progress_prev_line_length',
236                                    0)
237                 if prev_len > len(fullmsg):
238                     fullmsg += ' ' * (prev_len - len(fullmsg))
239                 self._report_progress_prev_line_length = len(fullmsg)
240                 clear_line = '\r'
241             else:
242                 clear_line = ('\r\x1b[K' if sys.stderr.isatty() else '\r')
243             self.to_screen(clear_line + fullmsg, skip_eol=not is_last_line)
244         self.to_console_title('youtube-dl ' + msg)
245
246     def report_progress(self, s):
247         if s['status'] == 'finished':
248             if self.params.get('noprogress', False):
249                 self.to_screen('[download] Download completed')
250             else:
251                 msg_template = '100%%'
252                 if s.get('total_bytes') is not None:
253                     s['_total_bytes_str'] = format_bytes(s['total_bytes'])
254                     msg_template += ' of %(_total_bytes_str)s'
255                 if s.get('elapsed') is not None:
256                     s['_elapsed_str'] = self.format_seconds(s['elapsed'])
257                     msg_template += ' in %(_elapsed_str)s'
258                 self._report_progress_status(
259                     msg_template % s, is_last_line=True)
260
261         if self.params.get('noprogress'):
262             return
263
264         if s['status'] != 'downloading':
265             return
266
267         if s.get('eta') is not None:
268             s['_eta_str'] = self.format_eta(s['eta'])
269         else:
270             s['_eta_str'] = 'Unknown ETA'
271
272         if s.get('total_bytes') and s.get('downloaded_bytes') is not None:
273             s['_percent_str'] = self.format_percent(100 * s['downloaded_bytes'] / s['total_bytes'])
274         elif s.get('total_bytes_estimate') and s.get('downloaded_bytes') is not None:
275             s['_percent_str'] = self.format_percent(100 * s['downloaded_bytes'] / s['total_bytes_estimate'])
276         else:
277             if s.get('downloaded_bytes') == 0:
278                 s['_percent_str'] = self.format_percent(0)
279             else:
280                 s['_percent_str'] = 'Unknown %'
281
282         if s.get('speed') is not None:
283             s['_speed_str'] = self.format_speed(s['speed'])
284         else:
285             s['_speed_str'] = 'Unknown speed'
286
287         if s.get('total_bytes') is not None:
288             s['_total_bytes_str'] = format_bytes(s['total_bytes'])
289             msg_template = '%(_percent_str)s of %(_total_bytes_str)s at %(_speed_str)s ETA %(_eta_str)s'
290         elif s.get('total_bytes_estimate') is not None:
291             s['_total_bytes_estimate_str'] = format_bytes(s['total_bytes_estimate'])
292             msg_template = '%(_percent_str)s of ~%(_total_bytes_estimate_str)s at %(_speed_str)s ETA %(_eta_str)s'
293         else:
294             if s.get('downloaded_bytes') is not None:
295                 s['_downloaded_bytes_str'] = format_bytes(s['downloaded_bytes'])
296                 if s.get('elapsed'):
297                     s['_elapsed_str'] = self.format_seconds(s['elapsed'])
298                     msg_template = '%(_downloaded_bytes_str)s at %(_speed_str)s (%(_elapsed_str)s)'
299                 else:
300                     msg_template = '%(_downloaded_bytes_str)s at %(_speed_str)s'
301             else:
302                 msg_template = '%(_percent_str)s % at %(_speed_str)s ETA %(_eta_str)s'
303
304         self._report_progress_status(msg_template % s)
305
306     def report_resuming_byte(self, resume_len):
307         """Report attempt to resume at given byte."""
308         self.to_screen('[download] Resuming download at byte %s' % resume_len)
309
310     def report_retry(self, err, count, retries):
311         """Report retry in case of HTTP error 5xx"""
312         self.to_screen(
313             '[download] Got server HTTP error: %s. Retrying (attempt %d of %s)...'
314             % (error_to_compat_str(err), count, self.format_retries(retries)))
315
316     def report_file_already_downloaded(self, file_name):
317         """Report file has already been fully downloaded."""
318         try:
319             self.to_screen('[download] %s has already been downloaded' % file_name)
320         except UnicodeEncodeError:
321             self.to_screen('[download] The file has already been downloaded')
322
323     def report_unable_to_resume(self):
324         """Report it was impossible to resume download."""
325         self.to_screen('[download] Unable to resume')
326
327     def download(self, filename, info_dict):
328         """Download to a filename using the info from info_dict
329         Return True on success and False otherwise
330         """
331
332         nooverwrites_and_exists = (
333             self.params.get('nooverwrites', False)
334             and os.path.exists(encodeFilename(filename))
335         )
336
337         if not hasattr(filename, 'write'):
338             continuedl_and_exists = (
339                 self.params.get('continuedl', True)
340                 and os.path.isfile(encodeFilename(filename))
341                 and not self.params.get('nopart', False)
342             )
343
344             # Check file already present
345             if filename != '-' and (nooverwrites_and_exists or continuedl_and_exists):
346                 self.report_file_already_downloaded(filename)
347                 self._hook_progress({
348                     'filename': filename,
349                     'status': 'finished',
350                     'total_bytes': os.path.getsize(encodeFilename(filename)),
351                 })
352                 return True
353
354         min_sleep_interval = self.params.get('sleep_interval')
355         if min_sleep_interval:
356             max_sleep_interval = self.params.get('max_sleep_interval', min_sleep_interval)
357             sleep_interval = random.uniform(min_sleep_interval, max_sleep_interval)
358             self.to_screen(
359                 '[download] Sleeping %s seconds...' % (
360                     int(sleep_interval) if sleep_interval.is_integer()
361                     else '%.2f' % sleep_interval))
362             time.sleep(sleep_interval)
363
364         return self.real_download(filename, info_dict)
365
366     def real_download(self, filename, info_dict):
367         """Real download process. Redefine in subclasses."""
368         raise NotImplementedError('This method must be implemented by subclasses')
369
370     def _hook_progress(self, status):
371         for ph in self._progress_hooks:
372             ph(status)
373
374     def add_progress_hook(self, ph):
375         # See YoutubeDl.py (search for progress_hooks) for a description of
376         # this interface
377         self._progress_hooks.append(ph)
378
379     def _debug_cmd(self, args, exe=None):
380         if not self.params.get('verbose', False):
381             return
382
383         str_args = [decodeArgument(a) for a in args]
384
385         if exe is None:
386             exe = os.path.basename(str_args[0])
387
388         self.to_screen('[debug] %s command line: %s' % (
389             exe, shell_quote(str_args)))