]> git.bitcoin.ninja Git - youtube-dl/blob - youtube_dl/YoutubeDL.py
[mfs] Modernize
[youtube-dl] / youtube_dl / YoutubeDL.py
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 from __future__ import absolute_import, unicode_literals
5
6 import collections
7 import datetime
8 import errno
9 import io
10 import json
11 import locale
12 import os
13 import platform
14 import re
15 import shutil
16 import subprocess
17 import socket
18 import sys
19 import time
20 import traceback
21
22 if os.name == 'nt':
23     import ctypes
24
25 from .utils import (
26     compat_cookiejar,
27     compat_http_client,
28     compat_str,
29     compat_urllib_error,
30     compat_urllib_request,
31     ContentTooShortError,
32     date_from_str,
33     DateRange,
34     DEFAULT_OUTTMPL,
35     determine_ext,
36     DownloadError,
37     encodeFilename,
38     ExtractorError,
39     format_bytes,
40     formatSeconds,
41     get_term_width,
42     locked_file,
43     make_HTTPS_handler,
44     MaxDownloadsReached,
45     PagedList,
46     PostProcessingError,
47     platform_name,
48     preferredencoding,
49     SameFileError,
50     sanitize_filename,
51     subtitles_filename,
52     takewhile_inclusive,
53     UnavailableVideoError,
54     url_basename,
55     write_json_file,
56     write_string,
57     YoutubeDLHandler,
58     prepend_extension,
59 )
60 from .extractor import get_info_extractor, gen_extractors
61 from .downloader import get_suitable_downloader
62 from .postprocessor import FFmpegMergerPP
63 from .version import __version__
64
65
66 class YoutubeDL(object):
67     """YoutubeDL class.
68
69     YoutubeDL objects are the ones responsible of downloading the
70     actual video file and writing it to disk if the user has requested
71     it, among some other tasks. In most cases there should be one per
72     program. As, given a video URL, the downloader doesn't know how to
73     extract all the needed information, task that InfoExtractors do, it
74     has to pass the URL to one of them.
75
76     For this, YoutubeDL objects have a method that allows
77     InfoExtractors to be registered in a given order. When it is passed
78     a URL, the YoutubeDL object handles it to the first InfoExtractor it
79     finds that reports being able to handle it. The InfoExtractor extracts
80     all the information about the video or videos the URL refers to, and
81     YoutubeDL process the extracted information, possibly using a File
82     Downloader to download the video.
83
84     YoutubeDL objects accept a lot of parameters. In order not to saturate
85     the object constructor with arguments, it receives a dictionary of
86     options instead. These options are available through the params
87     attribute for the InfoExtractors to use. The YoutubeDL also
88     registers itself as the downloader in charge for the InfoExtractors
89     that are added to it, so this is a "mutual registration".
90
91     Available options:
92
93     username:          Username for authentication purposes.
94     password:          Password for authentication purposes.
95     videopassword:     Password for acces a video.
96     usenetrc:          Use netrc for authentication instead.
97     verbose:           Print additional info to stdout.
98     quiet:             Do not print messages to stdout.
99     no_warnings:       Do not print out anything for warnings.
100     forceurl:          Force printing final URL.
101     forcetitle:        Force printing title.
102     forceid:           Force printing ID.
103     forcethumbnail:    Force printing thumbnail URL.
104     forcedescription:  Force printing description.
105     forcefilename:     Force printing final filename.
106     forceduration:     Force printing duration.
107     forcejson:         Force printing info_dict as JSON.
108     simulate:          Do not download the video files.
109     format:            Video format code.
110     format_limit:      Highest quality format to try.
111     outtmpl:           Template for output names.
112     restrictfilenames: Do not allow "&" and spaces in file names
113     ignoreerrors:      Do not stop on download errors.
114     nooverwrites:      Prevent overwriting files.
115     playliststart:     Playlist item to start at.
116     playlistend:       Playlist item to end at.
117     matchtitle:        Download only matching titles.
118     rejecttitle:       Reject downloads for matching titles.
119     logger:            Log messages to a logging.Logger instance.
120     logtostderr:       Log messages to stderr instead of stdout.
121     writedescription:  Write the video description to a .description file
122     writeinfojson:     Write the video description to a .info.json file
123     writeannotations:  Write the video annotations to a .annotations.xml file
124     writethumbnail:    Write the thumbnail image to a file
125     writesubtitles:    Write the video subtitles to a file
126     writeautomaticsub: Write the automatic subtitles to a file
127     allsubtitles:      Downloads all the subtitles of the video
128                        (requires writesubtitles or writeautomaticsub)
129     listsubtitles:     Lists all available subtitles for the video
130     subtitlesformat:   Subtitle format [srt/sbv/vtt] (default=srt)
131     subtitleslangs:    List of languages of the subtitles to download
132     keepvideo:         Keep the video file after post-processing
133     daterange:         A DateRange object, download only if the upload_date is in the range.
134     skip_download:     Skip the actual download of the video file
135     cachedir:          Location of the cache files in the filesystem.
136                        None to disable filesystem cache.
137     noplaylist:        Download single video instead of a playlist if in doubt.
138     age_limit:         An integer representing the user's age in years.
139                        Unsuitable videos for the given age are skipped.
140     min_views:         An integer representing the minimum view count the video
141                        must have in order to not be skipped.
142                        Videos without view count information are always
143                        downloaded. None for no limit.
144     max_views:         An integer representing the maximum view count.
145                        Videos that are more popular than that are not
146                        downloaded.
147                        Videos without view count information are always
148                        downloaded. None for no limit.
149     download_archive:  File name of a file where all downloads are recorded.
150                        Videos already present in the file are not downloaded
151                        again.
152     cookiefile:        File name where cookies should be read from and dumped to.
153     nocheckcertificate:Do not verify SSL certificates
154     prefer_insecure:   Use HTTP instead of HTTPS to retrieve information.
155                        At the moment, this is only supported by YouTube.
156     proxy:             URL of the proxy server to use
157     socket_timeout:    Time to wait for unresponsive hosts, in seconds
158     bidi_workaround:   Work around buggy terminals without bidirectional text
159                        support, using fridibi
160     debug_printtraffic:Print out sent and received HTTP traffic
161     include_ads:       Download ads as well
162     default_search:    Prepend this string if an input url is not valid.
163                        'auto' for elaborate guessing
164     encoding:          Use this encoding instead of the system-specified.
165     extract_flat:      Do not resolve URLs, return the immediate result.
166
167     The following parameters are not used by YoutubeDL itself, they are used by
168     the FileDownloader:
169     nopart, updatetime, buffersize, ratelimit, min_filesize, max_filesize, test,
170     noresizebuffer, retries, continuedl, noprogress, consoletitle
171
172     The following options are used by the post processors:
173     prefer_ffmpeg:     If True, use ffmpeg instead of avconv if both are available,
174                        otherwise prefer avconv.
175     exec_cmd:          Arbitrary command to run after downloading
176     """
177
178     params = None
179     _ies = []
180     _pps = []
181     _download_retcode = None
182     _num_downloads = None
183     _screen_file = None
184
185     def __init__(self, params=None):
186         """Create a FileDownloader object with the given options."""
187         if params is None:
188             params = {}
189         self._ies = []
190         self._ies_instances = {}
191         self._pps = []
192         self._progress_hooks = []
193         self._download_retcode = 0
194         self._num_downloads = 0
195         self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
196         self._err_file = sys.stderr
197         self.params = params
198
199         if params.get('bidi_workaround', False):
200             try:
201                 import pty
202                 master, slave = pty.openpty()
203                 width = get_term_width()
204                 if width is None:
205                     width_args = []
206                 else:
207                     width_args = ['-w', str(width)]
208                 sp_kwargs = dict(
209                     stdin=subprocess.PIPE,
210                     stdout=slave,
211                     stderr=self._err_file)
212                 try:
213                     self._output_process = subprocess.Popen(
214                         ['bidiv'] + width_args, **sp_kwargs
215                     )
216                 except OSError:
217                     self._output_process = subprocess.Popen(
218                         ['fribidi', '-c', 'UTF-8'] + width_args, **sp_kwargs)
219                 self._output_channel = os.fdopen(master, 'rb')
220             except OSError as ose:
221                 if ose.errno == 2:
222                     self.report_warning('Could not find fribidi executable, ignoring --bidi-workaround . Make sure that  fribidi  is an executable file in one of the directories in your $PATH.')
223                 else:
224                     raise
225
226         if (sys.version_info >= (3,) and sys.platform != 'win32' and
227                 sys.getfilesystemencoding() in ['ascii', 'ANSI_X3.4-1968']
228                 and not params['restrictfilenames']):
229             # On Python 3, the Unicode filesystem API will throw errors (#1474)
230             self.report_warning(
231                 'Assuming --restrict-filenames since file system encoding '
232                 'cannot encode all charactes. '
233                 'Set the LC_ALL environment variable to fix this.')
234             self.params['restrictfilenames'] = True
235
236         if '%(stitle)s' in self.params.get('outtmpl', ''):
237             self.report_warning('%(stitle)s is deprecated. Use the %(title)s and the --restrict-filenames flag(which also secures %(uploader)s et al) instead.')
238
239         self._setup_opener()
240
241     def add_info_extractor(self, ie):
242         """Add an InfoExtractor object to the end of the list."""
243         self._ies.append(ie)
244         self._ies_instances[ie.ie_key()] = ie
245         ie.set_downloader(self)
246
247     def get_info_extractor(self, ie_key):
248         """
249         Get an instance of an IE with name ie_key, it will try to get one from
250         the _ies list, if there's no instance it will create a new one and add
251         it to the extractor list.
252         """
253         ie = self._ies_instances.get(ie_key)
254         if ie is None:
255             ie = get_info_extractor(ie_key)()
256             self.add_info_extractor(ie)
257         return ie
258
259     def add_default_info_extractors(self):
260         """
261         Add the InfoExtractors returned by gen_extractors to the end of the list
262         """
263         for ie in gen_extractors():
264             self.add_info_extractor(ie)
265
266     def add_post_processor(self, pp):
267         """Add a PostProcessor object to the end of the chain."""
268         self._pps.append(pp)
269         pp.set_downloader(self)
270
271     def add_progress_hook(self, ph):
272         """Add the progress hook (currently only for the file downloader)"""
273         self._progress_hooks.append(ph)
274
275     def _bidi_workaround(self, message):
276         if not hasattr(self, '_output_channel'):
277             return message
278
279         assert hasattr(self, '_output_process')
280         assert isinstance(message, compat_str)
281         line_count = message.count('\n') + 1
282         self._output_process.stdin.write((message + '\n').encode('utf-8'))
283         self._output_process.stdin.flush()
284         res = ''.join(self._output_channel.readline().decode('utf-8')
285                        for _ in range(line_count))
286         return res[:-len('\n')]
287
288     def to_screen(self, message, skip_eol=False):
289         """Print message to stdout if not in quiet mode."""
290         return self.to_stdout(message, skip_eol, check_quiet=True)
291
292     def _write_string(self, s, out=None):
293         write_string(s, out=out, encoding=self.params.get('encoding'))
294
295     def to_stdout(self, message, skip_eol=False, check_quiet=False):
296         """Print message to stdout if not in quiet mode."""
297         if self.params.get('logger'):
298             self.params['logger'].debug(message)
299         elif not check_quiet or not self.params.get('quiet', False):
300             message = self._bidi_workaround(message)
301             terminator = ['\n', ''][skip_eol]
302             output = message + terminator
303
304             self._write_string(output, self._screen_file)
305
306     def to_stderr(self, message):
307         """Print message to stderr."""
308         assert isinstance(message, compat_str)
309         if self.params.get('logger'):
310             self.params['logger'].error(message)
311         else:
312             message = self._bidi_workaround(message)
313             output = message + '\n'
314             self._write_string(output, self._err_file)
315
316     def to_console_title(self, message):
317         if not self.params.get('consoletitle', False):
318             return
319         if os.name == 'nt' and ctypes.windll.kernel32.GetConsoleWindow():
320             # c_wchar_p() might not be necessary if `message` is
321             # already of type unicode()
322             ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
323         elif 'TERM' in os.environ:
324             self._write_string('\033]0;%s\007' % message, self._screen_file)
325
326     def save_console_title(self):
327         if not self.params.get('consoletitle', False):
328             return
329         if 'TERM' in os.environ:
330             # Save the title on stack
331             self._write_string('\033[22;0t', self._screen_file)
332
333     def restore_console_title(self):
334         if not self.params.get('consoletitle', False):
335             return
336         if 'TERM' in os.environ:
337             # Restore the title from stack
338             self._write_string('\033[23;0t', self._screen_file)
339
340     def __enter__(self):
341         self.save_console_title()
342         return self
343
344     def __exit__(self, *args):
345         self.restore_console_title()
346
347         if self.params.get('cookiefile') is not None:
348             self.cookiejar.save()
349
350     def trouble(self, message=None, tb=None):
351         """Determine action to take when a download problem appears.
352
353         Depending on if the downloader has been configured to ignore
354         download errors or not, this method may throw an exception or
355         not when errors are found, after printing the message.
356
357         tb, if given, is additional traceback information.
358         """
359         if message is not None:
360             self.to_stderr(message)
361         if self.params.get('verbose'):
362             if tb is None:
363                 if sys.exc_info()[0]:  # if .trouble has been called from an except block
364                     tb = ''
365                     if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
366                         tb += ''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
367                     tb += compat_str(traceback.format_exc())
368                 else:
369                     tb_data = traceback.format_list(traceback.extract_stack())
370                     tb = ''.join(tb_data)
371             self.to_stderr(tb)
372         if not self.params.get('ignoreerrors', False):
373             if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
374                 exc_info = sys.exc_info()[1].exc_info
375             else:
376                 exc_info = sys.exc_info()
377             raise DownloadError(message, exc_info)
378         self._download_retcode = 1
379
380     def report_warning(self, message):
381         '''
382         Print the message to stderr, it will be prefixed with 'WARNING:'
383         If stderr is a tty file the 'WARNING:' will be colored
384         '''
385         if self.params.get('logger') is not None:
386             self.params['logger'].warning(message)
387         else:
388             if self.params.get('no_warnings'):
389                 return
390             if self._err_file.isatty() and os.name != 'nt':
391                 _msg_header = '\033[0;33mWARNING:\033[0m'
392             else:
393                 _msg_header = 'WARNING:'
394             warning_message = '%s %s' % (_msg_header, message)
395             self.to_stderr(warning_message)
396
397     def report_error(self, message, tb=None):
398         '''
399         Do the same as trouble, but prefixes the message with 'ERROR:', colored
400         in red if stderr is a tty file.
401         '''
402         if self._err_file.isatty() and os.name != 'nt':
403             _msg_header = '\033[0;31mERROR:\033[0m'
404         else:
405             _msg_header = 'ERROR:'
406         error_message = '%s %s' % (_msg_header, message)
407         self.trouble(error_message, tb)
408
409     def report_file_already_downloaded(self, file_name):
410         """Report file has already been fully downloaded."""
411         try:
412             self.to_screen('[download] %s has already been downloaded' % file_name)
413         except UnicodeEncodeError:
414             self.to_screen('[download] The file has already been downloaded')
415
416     def prepare_filename(self, info_dict):
417         """Generate the output filename."""
418         try:
419             template_dict = dict(info_dict)
420
421             template_dict['epoch'] = int(time.time())
422             autonumber_size = self.params.get('autonumber_size')
423             if autonumber_size is None:
424                 autonumber_size = 5
425             autonumber_templ = '%0' + str(autonumber_size) + 'd'
426             template_dict['autonumber'] = autonumber_templ % self._num_downloads
427             if template_dict.get('playlist_index') is not None:
428                 template_dict['playlist_index'] = '%0*d' % (len(str(template_dict['n_entries'])), template_dict['playlist_index'])
429             if template_dict.get('resolution') is None:
430                 if template_dict.get('width') and template_dict.get('height'):
431                     template_dict['resolution'] = '%dx%d' % (template_dict['width'], template_dict['height'])
432                 elif template_dict.get('height'):
433                     template_dict['resolution'] = '%sp' % template_dict['height']
434                 elif template_dict.get('width'):
435                     template_dict['resolution'] = '?x%d' % template_dict['width']
436
437             sanitize = lambda k, v: sanitize_filename(
438                 compat_str(v),
439                 restricted=self.params.get('restrictfilenames'),
440                 is_id=(k == 'id'))
441             template_dict = dict((k, sanitize(k, v))
442                                  for k, v in template_dict.items()
443                                  if v is not None)
444             template_dict = collections.defaultdict(lambda: 'NA', template_dict)
445
446             outtmpl = self.params.get('outtmpl', DEFAULT_OUTTMPL)
447             tmpl = os.path.expanduser(outtmpl)
448             filename = tmpl % template_dict
449             return filename
450         except ValueError as err:
451             self.report_error('Error in output template: ' + str(err) + ' (encoding: ' + repr(preferredencoding()) + ')')
452             return None
453
454     def _match_entry(self, info_dict):
455         """ Returns None iff the file should be downloaded """
456
457         video_title = info_dict.get('title', info_dict.get('id', 'video'))
458         if 'title' in info_dict:
459             # This can happen when we're just evaluating the playlist
460             title = info_dict['title']
461             matchtitle = self.params.get('matchtitle', False)
462             if matchtitle:
463                 if not re.search(matchtitle, title, re.IGNORECASE):
464                     return '"' + title + '" title did not match pattern "' + matchtitle + '"'
465             rejecttitle = self.params.get('rejecttitle', False)
466             if rejecttitle:
467                 if re.search(rejecttitle, title, re.IGNORECASE):
468                     return '"' + title + '" title matched reject pattern "' + rejecttitle + '"'
469         date = info_dict.get('upload_date', None)
470         if date is not None:
471             dateRange = self.params.get('daterange', DateRange())
472             if date not in dateRange:
473                 return '%s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
474         view_count = info_dict.get('view_count', None)
475         if view_count is not None:
476             min_views = self.params.get('min_views')
477             if min_views is not None and view_count < min_views:
478                 return 'Skipping %s, because it has not reached minimum view count (%d/%d)' % (video_title, view_count, min_views)
479             max_views = self.params.get('max_views')
480             if max_views is not None and view_count > max_views:
481                 return 'Skipping %s, because it has exceeded the maximum view count (%d/%d)' % (video_title, view_count, max_views)
482         age_limit = self.params.get('age_limit')
483         if age_limit is not None:
484             actual_age_limit = info_dict.get('age_limit')
485             if actual_age_limit is None:
486                 actual_age_limit = 0
487             if age_limit < actual_age_limit:
488                 return 'Skipping "' + title + '" because it is age restricted'
489         if self.in_download_archive(info_dict):
490             return '%s has already been recorded in archive' % video_title
491         return None
492
493     @staticmethod
494     def add_extra_info(info_dict, extra_info):
495         '''Set the keys from extra_info in info dict if they are missing'''
496         for key, value in extra_info.items():
497             info_dict.setdefault(key, value)
498
499     def extract_info(self, url, download=True, ie_key=None, extra_info={},
500                      process=True):
501         '''
502         Returns a list with a dictionary for each video we find.
503         If 'download', also downloads the videos.
504         extra_info is a dict containing the extra values to add to each result
505          '''
506
507         if ie_key:
508             ies = [self.get_info_extractor(ie_key)]
509         else:
510             ies = self._ies
511
512         for ie in ies:
513             if not ie.suitable(url):
514                 continue
515
516             if not ie.working():
517                 self.report_warning('The program functionality for this site has been marked as broken, '
518                                     'and will probably not work.')
519
520             try:
521                 ie_result = ie.extract(url)
522                 if ie_result is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
523                     break
524                 if isinstance(ie_result, list):
525                     # Backwards compatibility: old IE result format
526                     ie_result = {
527                         '_type': 'compat_list',
528                         'entries': ie_result,
529                     }
530                 self.add_default_extra_info(ie_result, ie, url)
531                 if process:
532                     return self.process_ie_result(ie_result, download, extra_info)
533                 else:
534                     return ie_result
535             except ExtractorError as de: # An error we somewhat expected
536                 self.report_error(compat_str(de), de.format_traceback())
537                 break
538             except MaxDownloadsReached:
539                 raise
540             except Exception as e:
541                 if self.params.get('ignoreerrors', False):
542                     self.report_error(compat_str(e), tb=compat_str(traceback.format_exc()))
543                     break
544                 else:
545                     raise
546         else:
547             self.report_error('no suitable InfoExtractor for URL %s' % url)
548
549     def add_default_extra_info(self, ie_result, ie, url):
550         self.add_extra_info(ie_result, {
551             'extractor': ie.IE_NAME,
552             'webpage_url': url,
553             'webpage_url_basename': url_basename(url),
554             'extractor_key': ie.ie_key(),
555         })
556
557     def process_ie_result(self, ie_result, download=True, extra_info={}):
558         """
559         Take the result of the ie(may be modified) and resolve all unresolved
560         references (URLs, playlist items).
561
562         It will also download the videos if 'download'.
563         Returns the resolved ie_result.
564         """
565
566         result_type = ie_result.get('_type', 'video')
567
568         if self.params.get('extract_flat', False):
569             if result_type in ('url', 'url_transparent'):
570                 return ie_result
571
572         if result_type == 'video':
573             self.add_extra_info(ie_result, extra_info)
574             return self.process_video_result(ie_result, download=download)
575         elif result_type == 'url':
576             # We have to add extra_info to the results because it may be
577             # contained in a playlist
578             return self.extract_info(ie_result['url'],
579                                      download,
580                                      ie_key=ie_result.get('ie_key'),
581                                      extra_info=extra_info)
582         elif result_type == 'url_transparent':
583             # Use the information from the embedding page
584             info = self.extract_info(
585                 ie_result['url'], ie_key=ie_result.get('ie_key'),
586                 extra_info=extra_info, download=False, process=False)
587
588             def make_result(embedded_info):
589                 new_result = ie_result.copy()
590                 for f in ('_type', 'url', 'ext', 'player_url', 'formats',
591                           'entries', 'ie_key', 'duration',
592                           'subtitles', 'annotations', 'format',
593                           'thumbnail', 'thumbnails'):
594                     if f in new_result:
595                         del new_result[f]
596                     if f in embedded_info:
597                         new_result[f] = embedded_info[f]
598                 return new_result
599             new_result = make_result(info)
600
601             assert new_result.get('_type') != 'url_transparent'
602             if new_result.get('_type') == 'compat_list':
603                 new_result['entries'] = [
604                     make_result(e) for e in new_result['entries']]
605
606             return self.process_ie_result(
607                 new_result, download=download, extra_info=extra_info)
608         elif result_type == 'playlist':
609             # We process each entry in the playlist
610             playlist = ie_result.get('title', None) or ie_result.get('id', None)
611             self.to_screen('[download] Downloading playlist: %s' % playlist)
612
613             playlist_results = []
614
615             playliststart = self.params.get('playliststart', 1) - 1
616             playlistend = self.params.get('playlistend', None)
617             # For backwards compatibility, interpret -1 as whole list
618             if playlistend == -1:
619                 playlistend = None
620
621             if isinstance(ie_result['entries'], list):
622                 n_all_entries = len(ie_result['entries'])
623                 entries = ie_result['entries'][playliststart:playlistend]
624                 n_entries = len(entries)
625                 self.to_screen(
626                     "[%s] playlist %s: Collected %d video ids (downloading %d of them)" %
627                     (ie_result['extractor'], playlist, n_all_entries, n_entries))
628             else:
629                 assert isinstance(ie_result['entries'], PagedList)
630                 entries = ie_result['entries'].getslice(
631                     playliststart, playlistend)
632                 n_entries = len(entries)
633                 self.to_screen(
634                     "[%s] playlist %s: Downloading %d videos" %
635                     (ie_result['extractor'], playlist, n_entries))
636
637             for i, entry in enumerate(entries, 1):
638                 self.to_screen('[download] Downloading video #%s of %s' % (i, n_entries))
639                 extra = {
640                     'n_entries': n_entries,
641                     'playlist': playlist,
642                     'playlist_index': i + playliststart,
643                     'extractor': ie_result['extractor'],
644                     'webpage_url': ie_result['webpage_url'],
645                     'webpage_url_basename': url_basename(ie_result['webpage_url']),
646                     'extractor_key': ie_result['extractor_key'],
647                 }
648
649                 reason = self._match_entry(entry)
650                 if reason is not None:
651                     self.to_screen('[download] ' + reason)
652                     continue
653
654                 entry_result = self.process_ie_result(entry,
655                                                       download=download,
656                                                       extra_info=extra)
657                 playlist_results.append(entry_result)
658             ie_result['entries'] = playlist_results
659             return ie_result
660         elif result_type == 'compat_list':
661             def _fixup(r):
662                 self.add_extra_info(r,
663                     {
664                         'extractor': ie_result['extractor'],
665                         'webpage_url': ie_result['webpage_url'],
666                         'webpage_url_basename': url_basename(ie_result['webpage_url']),
667                         'extractor_key': ie_result['extractor_key'],
668                     })
669                 return r
670             ie_result['entries'] = [
671                 self.process_ie_result(_fixup(r), download, extra_info)
672                 for r in ie_result['entries']
673             ]
674             return ie_result
675         else:
676             raise Exception('Invalid result type: %s' % result_type)
677
678     def select_format(self, format_spec, available_formats):
679         if format_spec == 'best' or format_spec is None:
680             return available_formats[-1]
681         elif format_spec == 'worst':
682             return available_formats[0]
683         elif format_spec == 'bestaudio':
684             audio_formats = [
685                 f for f in available_formats
686                 if f.get('vcodec') == 'none']
687             if audio_formats:
688                 return audio_formats[-1]
689         elif format_spec == 'worstaudio':
690             audio_formats = [
691                 f for f in available_formats
692                 if f.get('vcodec') == 'none']
693             if audio_formats:
694                 return audio_formats[0]
695         elif format_spec == 'bestvideo':
696             video_formats = [
697                 f for f in available_formats
698                 if f.get('acodec') == 'none']
699             if video_formats:
700                 return video_formats[-1]
701         elif format_spec == 'worstvideo':
702             video_formats = [
703                 f for f in available_formats
704                 if f.get('acodec') == 'none']
705             if video_formats:
706                 return video_formats[0]
707         else:
708             extensions = ['mp4', 'flv', 'webm', '3gp']
709             if format_spec in extensions:
710                 filter_f = lambda f: f['ext'] == format_spec
711             else:
712                 filter_f = lambda f: f['format_id'] == format_spec
713             matches = list(filter(filter_f, available_formats))
714             if matches:
715                 return matches[-1]
716         return None
717
718     def process_video_result(self, info_dict, download=True):
719         assert info_dict.get('_type', 'video') == 'video'
720
721         if 'id' not in info_dict:
722             raise ExtractorError('Missing "id" field in extractor result')
723         if 'title' not in info_dict:
724             raise ExtractorError('Missing "title" field in extractor result')
725
726         if 'playlist' not in info_dict:
727             # It isn't part of a playlist
728             info_dict['playlist'] = None
729             info_dict['playlist_index'] = None
730
731         thumbnails = info_dict.get('thumbnails')
732         if thumbnails:
733             thumbnails.sort(key=lambda t: (
734                 t.get('width'), t.get('height'), t.get('url')))
735             for t in thumbnails:
736                 if 'width' in t and 'height' in t:
737                     t['resolution'] = '%dx%d' % (t['width'], t['height'])
738
739         if thumbnails and 'thumbnail' not in info_dict:
740             info_dict['thumbnail'] = thumbnails[-1]['url']
741
742         if 'display_id' not in info_dict and 'id' in info_dict:
743             info_dict['display_id'] = info_dict['id']
744
745         if info_dict.get('upload_date') is None and info_dict.get('timestamp') is not None:
746             upload_date = datetime.datetime.utcfromtimestamp(
747                 info_dict['timestamp'])
748             info_dict['upload_date'] = upload_date.strftime('%Y%m%d')
749
750         # This extractors handle format selection themselves
751         if info_dict['extractor'] in ['Youku']:
752             if download:
753                 self.process_info(info_dict)
754             return info_dict
755
756         # We now pick which formats have to be downloaded
757         if info_dict.get('formats') is None:
758             # There's only one format available
759             formats = [info_dict]
760         else:
761             formats = info_dict['formats']
762
763         if not formats:
764             raise ExtractorError('No video formats found!')
765
766         # We check that all the formats have the format and format_id fields
767         for i, format in enumerate(formats):
768             if 'url' not in format:
769                 raise ExtractorError('Missing "url" key in result (index %d)' % i)
770
771             if format.get('format_id') is None:
772                 format['format_id'] = compat_str(i)
773             if format.get('format') is None:
774                 format['format'] = '{id} - {res}{note}'.format(
775                     id=format['format_id'],
776                     res=self.format_resolution(format),
777                     note=' ({0})'.format(format['format_note']) if format.get('format_note') is not None else '',
778                 )
779             # Automatically determine file extension if missing
780             if 'ext' not in format:
781                 format['ext'] = determine_ext(format['url']).lower()
782
783         format_limit = self.params.get('format_limit', None)
784         if format_limit:
785             formats = list(takewhile_inclusive(
786                 lambda f: f['format_id'] != format_limit, formats
787             ))
788
789         # TODO Central sorting goes here
790
791         if formats[0] is not info_dict:
792             # only set the 'formats' fields if the original info_dict list them
793             # otherwise we end up with a circular reference, the first (and unique)
794             # element in the 'formats' field in info_dict is info_dict itself,
795             # wich can't be exported to json
796             info_dict['formats'] = formats
797         if self.params.get('listformats', None):
798             self.list_formats(info_dict)
799             return
800
801         req_format = self.params.get('format')
802         if req_format is None:
803             req_format = 'best'
804         formats_to_download = []
805         # The -1 is for supporting YoutubeIE
806         if req_format in ('-1', 'all'):
807             formats_to_download = formats
808         else:
809             # We can accept formats requested in the format: 34/5/best, we pick
810             # the first that is available, starting from left
811             req_formats = req_format.split('/')
812             for rf in req_formats:
813                 if re.match(r'.+?\+.+?', rf) is not None:
814                     # Two formats have been requested like '137+139'
815                     format_1, format_2 = rf.split('+')
816                     formats_info = (self.select_format(format_1, formats),
817                         self.select_format(format_2, formats))
818                     if all(formats_info):
819                         selected_format = {
820                             'requested_formats': formats_info,
821                             'format': rf,
822                             'ext': formats_info[0]['ext'],
823                         }
824                     else:
825                         selected_format = None
826                 else:
827                     selected_format = self.select_format(rf, formats)
828                 if selected_format is not None:
829                     formats_to_download = [selected_format]
830                     break
831         if not formats_to_download:
832             raise ExtractorError('requested format not available',
833                                  expected=True)
834
835         if download:
836             if len(formats_to_download) > 1:
837                 self.to_screen('[info] %s: downloading video in %s formats' % (info_dict['id'], len(formats_to_download)))
838             for format in formats_to_download:
839                 new_info = dict(info_dict)
840                 new_info.update(format)
841                 self.process_info(new_info)
842         # We update the info dict with the best quality format (backwards compatibility)
843         info_dict.update(formats_to_download[-1])
844         return info_dict
845
846     def process_info(self, info_dict):
847         """Process a single resolved IE result."""
848
849         assert info_dict.get('_type', 'video') == 'video'
850
851         max_downloads = self.params.get('max_downloads')
852         if max_downloads is not None:
853             if self._num_downloads >= int(max_downloads):
854                 raise MaxDownloadsReached()
855
856         info_dict['fulltitle'] = info_dict['title']
857         if len(info_dict['title']) > 200:
858             info_dict['title'] = info_dict['title'][:197] + '...'
859
860         # Keep for backwards compatibility
861         info_dict['stitle'] = info_dict['title']
862
863         if 'format' not in info_dict:
864             info_dict['format'] = info_dict['ext']
865
866         reason = self._match_entry(info_dict)
867         if reason is not None:
868             self.to_screen('[download] ' + reason)
869             return
870
871         self._num_downloads += 1
872
873         filename = self.prepare_filename(info_dict)
874
875         # Forced printings
876         if self.params.get('forcetitle', False):
877             self.to_stdout(info_dict['fulltitle'])
878         if self.params.get('forceid', False):
879             self.to_stdout(info_dict['id'])
880         if self.params.get('forceurl', False):
881             # For RTMP URLs, also include the playpath
882             self.to_stdout(info_dict['url'] + info_dict.get('play_path', ''))
883         if self.params.get('forcethumbnail', False) and info_dict.get('thumbnail') is not None:
884             self.to_stdout(info_dict['thumbnail'])
885         if self.params.get('forcedescription', False) and info_dict.get('description') is not None:
886             self.to_stdout(info_dict['description'])
887         if self.params.get('forcefilename', False) and filename is not None:
888             self.to_stdout(filename)
889         if self.params.get('forceduration', False) and info_dict.get('duration') is not None:
890             self.to_stdout(formatSeconds(info_dict['duration']))
891         if self.params.get('forceformat', False):
892             self.to_stdout(info_dict['format'])
893         if self.params.get('forcejson', False):
894             info_dict['_filename'] = filename
895             self.to_stdout(json.dumps(info_dict))
896
897         # Do nothing else if in simulate mode
898         if self.params.get('simulate', False):
899             return
900
901         if filename is None:
902             return
903
904         try:
905             dn = os.path.dirname(encodeFilename(filename))
906             if dn and not os.path.exists(dn):
907                 os.makedirs(dn)
908         except (OSError, IOError) as err:
909             self.report_error('unable to create directory ' + compat_str(err))
910             return
911
912         if self.params.get('writedescription', False):
913             descfn = filename + '.description'
914             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(descfn)):
915                 self.to_screen('[info] Video description is already present')
916             else:
917                 try:
918                     self.to_screen('[info] Writing video description to: ' + descfn)
919                     with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
920                         descfile.write(info_dict['description'])
921                 except (KeyError, TypeError):
922                     self.report_warning('There\'s no description to write.')
923                 except (OSError, IOError):
924                     self.report_error('Cannot write description file ' + descfn)
925                     return
926
927         if self.params.get('writeannotations', False):
928             annofn = filename + '.annotations.xml'
929             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(annofn)):
930                 self.to_screen('[info] Video annotations are already present')
931             else:
932                 try:
933                     self.to_screen('[info] Writing video annotations to: ' + annofn)
934                     with io.open(encodeFilename(annofn), 'w', encoding='utf-8') as annofile:
935                         annofile.write(info_dict['annotations'])
936                 except (KeyError, TypeError):
937                     self.report_warning('There are no annotations to write.')
938                 except (OSError, IOError):
939                     self.report_error('Cannot write annotations file: ' + annofn)
940                     return
941
942         subtitles_are_requested = any([self.params.get('writesubtitles', False),
943                                        self.params.get('writeautomaticsub')])
944
945         if subtitles_are_requested and 'subtitles' in info_dict and info_dict['subtitles']:
946             # subtitles download errors are already managed as troubles in relevant IE
947             # that way it will silently go on when used with unsupporting IE
948             subtitles = info_dict['subtitles']
949             sub_format = self.params.get('subtitlesformat', 'srt')
950             for sub_lang in subtitles.keys():
951                 sub = subtitles[sub_lang]
952                 if sub is None:
953                     continue
954                 try:
955                     sub_filename = subtitles_filename(filename, sub_lang, sub_format)
956                     if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(sub_filename)):
957                         self.to_screen('[info] Video subtitle %s.%s is already_present' % (sub_lang, sub_format))
958                     else:
959                         self.to_screen('[info] Writing video subtitles to: ' + sub_filename)
960                         with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
961                                 subfile.write(sub)
962                 except (OSError, IOError):
963                     self.report_error('Cannot write subtitles file ' + sub_filename)
964                     return
965
966         if self.params.get('writeinfojson', False):
967             infofn = os.path.splitext(filename)[0] + '.info.json'
968             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(infofn)):
969                 self.to_screen('[info] Video description metadata is already present')
970             else:
971                 self.to_screen('[info] Writing video description metadata as JSON to: ' + infofn)
972                 try:
973                     write_json_file(info_dict, encodeFilename(infofn))
974                 except (OSError, IOError):
975                     self.report_error('Cannot write metadata to JSON file ' + infofn)
976                     return
977
978         if self.params.get('writethumbnail', False):
979             if info_dict.get('thumbnail') is not None:
980                 thumb_format = determine_ext(info_dict['thumbnail'], 'jpg')
981                 thumb_filename = os.path.splitext(filename)[0] + '.' + thumb_format
982                 if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(thumb_filename)):
983                     self.to_screen('[%s] %s: Thumbnail is already present' %
984                                    (info_dict['extractor'], info_dict['id']))
985                 else:
986                     self.to_screen('[%s] %s: Downloading thumbnail ...' %
987                                    (info_dict['extractor'], info_dict['id']))
988                     try:
989                         uf = self.urlopen(info_dict['thumbnail'])
990                         with open(thumb_filename, 'wb') as thumbf:
991                             shutil.copyfileobj(uf, thumbf)
992                         self.to_screen('[%s] %s: Writing thumbnail to: %s' %
993                             (info_dict['extractor'], info_dict['id'], thumb_filename))
994                     except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
995                         self.report_warning('Unable to download thumbnail "%s": %s' %
996                             (info_dict['thumbnail'], compat_str(err)))
997
998         if not self.params.get('skip_download', False):
999             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
1000                 success = True
1001             else:
1002                 try:
1003                     def dl(name, info):
1004                         fd = get_suitable_downloader(info)(self, self.params)
1005                         for ph in self._progress_hooks:
1006                             fd.add_progress_hook(ph)
1007                         if self.params.get('verbose'):
1008                             self.to_stdout('[debug] Invoking downloader on %r' % info.get('url'))
1009                         return fd.download(name, info)
1010                     if info_dict.get('requested_formats') is not None:
1011                         downloaded = []
1012                         success = True
1013                         merger = FFmpegMergerPP(self, not self.params.get('keepvideo'))
1014                         if not merger._get_executable():
1015                             postprocessors = []
1016                             self.report_warning('You have requested multiple '
1017                                 'formats but ffmpeg or avconv are not installed.'
1018                                 ' The formats won\'t be merged')
1019                         else:
1020                             postprocessors = [merger]
1021                         for f in info_dict['requested_formats']:
1022                             new_info = dict(info_dict)
1023                             new_info.update(f)
1024                             fname = self.prepare_filename(new_info)
1025                             fname = prepend_extension(fname, 'f%s' % f['format_id'])
1026                             downloaded.append(fname)
1027                             partial_success = dl(fname, new_info)
1028                             success = success and partial_success
1029                         info_dict['__postprocessors'] = postprocessors
1030                         info_dict['__files_to_merge'] = downloaded
1031                     else:
1032                         # Just a single file
1033                         success = dl(filename, info_dict)
1034                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
1035                     self.report_error('unable to download video data: %s' % str(err))
1036                     return
1037                 except (OSError, IOError) as err:
1038                     raise UnavailableVideoError(err)
1039                 except (ContentTooShortError, ) as err:
1040                     self.report_error('content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
1041                     return
1042
1043             if success:
1044                 try:
1045                     self.post_process(filename, info_dict)
1046                 except (PostProcessingError) as err:
1047                     self.report_error('postprocessing: %s' % str(err))
1048                     return
1049
1050         self.record_download_archive(info_dict)
1051
1052     def download(self, url_list):
1053         """Download a given list of URLs."""
1054         outtmpl = self.params.get('outtmpl', DEFAULT_OUTTMPL)
1055         if (len(url_list) > 1 and
1056                 '%' not in outtmpl
1057                 and self.params.get('max_downloads') != 1):
1058             raise SameFileError(outtmpl)
1059
1060         for url in url_list:
1061             try:
1062                 #It also downloads the videos
1063                 self.extract_info(url)
1064             except UnavailableVideoError:
1065                 self.report_error('unable to download video')
1066             except MaxDownloadsReached:
1067                 self.to_screen('[info] Maximum number of downloaded files reached.')
1068                 raise
1069
1070         return self._download_retcode
1071
1072     def download_with_info_file(self, info_filename):
1073         with io.open(info_filename, 'r', encoding='utf-8') as f:
1074             info = json.load(f)
1075         try:
1076             self.process_ie_result(info, download=True)
1077         except DownloadError:
1078             webpage_url = info.get('webpage_url')
1079             if webpage_url is not None:
1080                 self.report_warning('The info failed to download, trying with "%s"' % webpage_url)
1081                 return self.download([webpage_url])
1082             else:
1083                 raise
1084         return self._download_retcode
1085
1086     def post_process(self, filename, ie_info):
1087         """Run all the postprocessors on the given file."""
1088         info = dict(ie_info)
1089         info['filepath'] = filename
1090         keep_video = None
1091         pps_chain = []
1092         if ie_info.get('__postprocessors') is not None:
1093             pps_chain.extend(ie_info['__postprocessors'])
1094         pps_chain.extend(self._pps)
1095         for pp in pps_chain:
1096             try:
1097                 keep_video_wish, new_info = pp.run(info)
1098                 if keep_video_wish is not None:
1099                     if keep_video_wish:
1100                         keep_video = keep_video_wish
1101                     elif keep_video is None:
1102                         # No clear decision yet, let IE decide
1103                         keep_video = keep_video_wish
1104             except PostProcessingError as e:
1105                 self.report_error(e.msg)
1106         if keep_video is False and not self.params.get('keepvideo', False):
1107             try:
1108                 self.to_screen('Deleting original file %s (pass -k to keep)' % filename)
1109                 os.remove(encodeFilename(filename))
1110             except (IOError, OSError):
1111                 self.report_warning('Unable to remove downloaded video file')
1112
1113     def _make_archive_id(self, info_dict):
1114         # Future-proof against any change in case
1115         # and backwards compatibility with prior versions
1116         extractor = info_dict.get('extractor_key')
1117         if extractor is None:
1118             if 'id' in info_dict:
1119                 extractor = info_dict.get('ie_key')  # key in a playlist
1120         if extractor is None:
1121             return None  # Incomplete video information
1122         return extractor.lower() + ' ' + info_dict['id']
1123
1124     def in_download_archive(self, info_dict):
1125         fn = self.params.get('download_archive')
1126         if fn is None:
1127             return False
1128
1129         vid_id = self._make_archive_id(info_dict)
1130         if vid_id is None:
1131             return False  # Incomplete video information
1132
1133         try:
1134             with locked_file(fn, 'r', encoding='utf-8') as archive_file:
1135                 for line in archive_file:
1136                     if line.strip() == vid_id:
1137                         return True
1138         except IOError as ioe:
1139             if ioe.errno != errno.ENOENT:
1140                 raise
1141         return False
1142
1143     def record_download_archive(self, info_dict):
1144         fn = self.params.get('download_archive')
1145         if fn is None:
1146             return
1147         vid_id = self._make_archive_id(info_dict)
1148         assert vid_id
1149         with locked_file(fn, 'a', encoding='utf-8') as archive_file:
1150             archive_file.write(vid_id + '\n')
1151
1152     @staticmethod
1153     def format_resolution(format, default='unknown'):
1154         if format.get('vcodec') == 'none':
1155             return 'audio only'
1156         if format.get('resolution') is not None:
1157             return format['resolution']
1158         if format.get('height') is not None:
1159             if format.get('width') is not None:
1160                 res = '%sx%s' % (format['width'], format['height'])
1161             else:
1162                 res = '%sp' % format['height']
1163         elif format.get('width') is not None:
1164             res = '?x%d' % format['width']
1165         else:
1166             res = default
1167         return res
1168
1169     def _format_note(self, fdict):
1170         res = ''
1171         if fdict.get('ext') in ['f4f', 'f4m']:
1172             res += '(unsupported) '
1173         if fdict.get('format_note') is not None:
1174             res += fdict['format_note'] + ' '
1175         if fdict.get('tbr') is not None:
1176             res += '%4dk ' % fdict['tbr']
1177         if fdict.get('container') is not None:
1178             if res:
1179                 res += ', '
1180             res += '%s container' % fdict['container']
1181         if (fdict.get('vcodec') is not None and
1182                 fdict.get('vcodec') != 'none'):
1183             if res:
1184                 res += ', '
1185             res += fdict['vcodec']
1186             if fdict.get('vbr') is not None:
1187                 res += '@'
1188         elif fdict.get('vbr') is not None and fdict.get('abr') is not None:
1189             res += 'video@'
1190         if fdict.get('vbr') is not None:
1191             res += '%4dk' % fdict['vbr']
1192         if fdict.get('acodec') is not None:
1193             if res:
1194                 res += ', '
1195             if fdict['acodec'] == 'none':
1196                 res += 'video only'
1197             else:
1198                 res += '%-5s' % fdict['acodec']
1199         elif fdict.get('abr') is not None:
1200             if res:
1201                 res += ', '
1202             res += 'audio'
1203         if fdict.get('abr') is not None:
1204             res += '@%3dk' % fdict['abr']
1205         if fdict.get('asr') is not None:
1206             res += ' (%5dHz)' % fdict['asr']
1207         if fdict.get('filesize') is not None:
1208             if res:
1209                 res += ', '
1210             res += format_bytes(fdict['filesize'])
1211         elif fdict.get('filesize_approx') is not None:
1212             if res:
1213                 res += ', '
1214             res += '~' + format_bytes(fdict['filesize_approx'])
1215         return res
1216
1217     def list_formats(self, info_dict):
1218         def line(format, idlen=20):
1219             return (('%-' + compat_str(idlen + 1) + 's%-10s%-12s%s') % (
1220                 format['format_id'],
1221                 format['ext'],
1222                 self.format_resolution(format),
1223                 self._format_note(format),
1224             ))
1225
1226         formats = info_dict.get('formats', [info_dict])
1227         idlen = max(len('format code'),
1228                     max(len(f['format_id']) for f in formats))
1229         formats_s = [line(f, idlen) for f in formats]
1230         if len(formats) > 1:
1231             formats_s[0] += (' ' if self._format_note(formats[0]) else '') + '(worst)'
1232             formats_s[-1] += (' ' if self._format_note(formats[-1]) else '') + '(best)'
1233
1234         header_line = line({
1235             'format_id': 'format code', 'ext': 'extension',
1236             'resolution': 'resolution', 'format_note': 'note'}, idlen=idlen)
1237         self.to_screen('[info] Available formats for %s:\n%s\n%s' %
1238                        (info_dict['id'], header_line, '\n'.join(formats_s)))
1239
1240     def urlopen(self, req):
1241         """ Start an HTTP download """
1242         return self._opener.open(req, timeout=self._socket_timeout)
1243
1244     def print_debug_header(self):
1245         if not self.params.get('verbose'):
1246             return
1247
1248         if type('') is not compat_str:
1249             # Python 2.6 on SLES11 SP1 (https://github.com/rg3/youtube-dl/issues/3326)
1250             self.report_warning(
1251                 'Your Python is broken! Update to a newer and supported version')
1252
1253         encoding_str = (
1254             '[debug] Encodings: locale %s, fs %s, out %s, pref %s\n' % (
1255                 locale.getpreferredencoding(),
1256                 sys.getfilesystemencoding(),
1257                 sys.stdout.encoding,
1258                 self.get_encoding()))
1259         write_string(encoding_str, encoding=None)
1260
1261         self._write_string('[debug] youtube-dl version ' + __version__ + '\n')
1262         try:
1263             sp = subprocess.Popen(
1264                 ['git', 'rev-parse', '--short', 'HEAD'],
1265                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
1266                 cwd=os.path.dirname(os.path.abspath(__file__)))
1267             out, err = sp.communicate()
1268             out = out.decode().strip()
1269             if re.match('[0-9a-f]+', out):
1270                 self._write_string('[debug] Git HEAD: ' + out + '\n')
1271         except:
1272             try:
1273                 sys.exc_clear()
1274             except:
1275                 pass
1276         self._write_string('[debug] Python version %s - %s' %
1277                      (platform.python_version(), platform_name()) + '\n')
1278
1279         proxy_map = {}
1280         for handler in self._opener.handlers:
1281             if hasattr(handler, 'proxies'):
1282                 proxy_map.update(handler.proxies)
1283         self._write_string('[debug] Proxy map: ' + compat_str(proxy_map) + '\n')
1284
1285     def _setup_opener(self):
1286         timeout_val = self.params.get('socket_timeout')
1287         self._socket_timeout = 600 if timeout_val is None else float(timeout_val)
1288
1289         opts_cookiefile = self.params.get('cookiefile')
1290         opts_proxy = self.params.get('proxy')
1291
1292         if opts_cookiefile is None:
1293             self.cookiejar = compat_cookiejar.CookieJar()
1294         else:
1295             self.cookiejar = compat_cookiejar.MozillaCookieJar(
1296                 opts_cookiefile)
1297             if os.access(opts_cookiefile, os.R_OK):
1298                 self.cookiejar.load()
1299
1300         cookie_processor = compat_urllib_request.HTTPCookieProcessor(
1301             self.cookiejar)
1302         if opts_proxy is not None:
1303             if opts_proxy == '':
1304                 proxies = {}
1305             else:
1306                 proxies = {'http': opts_proxy, 'https': opts_proxy}
1307         else:
1308             proxies = compat_urllib_request.getproxies()
1309             # Set HTTPS proxy to HTTP one if given (https://github.com/rg3/youtube-dl/issues/805)
1310             if 'http' in proxies and 'https' not in proxies:
1311                 proxies['https'] = proxies['http']
1312         proxy_handler = compat_urllib_request.ProxyHandler(proxies)
1313
1314         debuglevel = 1 if self.params.get('debug_printtraffic') else 0
1315         https_handler = make_HTTPS_handler(
1316             self.params.get('nocheckcertificate', False), debuglevel=debuglevel)
1317         ydlh = YoutubeDLHandler(debuglevel=debuglevel)
1318         opener = compat_urllib_request.build_opener(
1319             https_handler, proxy_handler, cookie_processor, ydlh)
1320         # Delete the default user-agent header, which would otherwise apply in
1321         # cases where our custom HTTP handler doesn't come into play
1322         # (See https://github.com/rg3/youtube-dl/issues/1309 for details)
1323         opener.addheaders = []
1324         self._opener = opener
1325
1326     def encode(self, s):
1327         if isinstance(s, bytes):
1328             return s  # Already encoded
1329
1330         try:
1331             return s.encode(self.get_encoding())
1332         except UnicodeEncodeError as err:
1333             err.reason = err.reason + '. Check your system encoding configuration or use the --encoding option.'
1334             raise
1335
1336     def get_encoding(self):
1337         encoding = self.params.get('encoding')
1338         if encoding is None:
1339             encoding = preferredencoding()
1340         return encoding