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

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from __future__ import unicode_literals
   5
   6 import calendar
   7 import codecs
   8 import contextlib
   9 import ctypes
  10 import datetime
  11 import email.utils
  12 import errno
  13 import functools
  14 import gzip
  15 import itertools
  16 import io
  17 import json
  18 import locale
  19 import math
  20 import operator
  21 import os
  22 import pipes
  23 import platform
  24 import re
  25 import ssl
  26 import socket
  27 import struct
  28 import subprocess
  29 import sys
  30 import tempfile
  31 import traceback
  32 import xml.etree.ElementTree
  33 import zlib
  34
  35 from .compat import (
  36     compat_basestring,
  37     compat_chr,
  38     compat_html_entities,
  39     compat_http_client,
  40     compat_kwargs,
  41     compat_parse_qs,
  42     compat_socket_create_connection,
  43     compat_str,
  44     compat_urllib_error,
  45     compat_urllib_parse,
  46     compat_urllib_parse_urlparse,
  47     compat_urllib_request,
  48     compat_urlparse,
  49     shlex_quote,
  50 )
  51
  52
  53 # This is not clearly defined otherwise
  54 compiled_regex_type = type(re.compile(''))
  55
  56 std_headers = {
  57     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20150101 Firefox/20.0 (Chrome)',
  58     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
  59     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  60     'Accept-Encoding': 'gzip, deflate',
  61     'Accept-Language': 'en-us,en;q=0.5',
  62 }
  63
  64
  65 ENGLISH_MONTH_NAMES = [
  66     'January', 'February', 'March', 'April', 'May', 'June',
  67     'July', 'August', 'September', 'October', 'November', 'December']
  68
  69
  70 def preferredencoding():
  71     """Get preferred encoding.
  72
  73     Returns the best encoding scheme for the system, based on
  74     locale.getpreferredencoding() and some further tweaks.
  75     """
  76     try:
  77         pref = locale.getpreferredencoding()
  78         'TEST'.encode(pref)
  79     except Exception:
  80         pref = 'UTF-8'
  81
  82     return pref
  83
  84
  85 def write_json_file(obj, fn):
  86     """ Encode obj as JSON and write it to fn, atomically if possible """
  87
  88     fn = encodeFilename(fn)
  89     if sys.version_info < (3, 0) and sys.platform != 'win32':
  90         encoding = get_filesystem_encoding()
  91         # os.path.basename returns a bytes object, but NamedTemporaryFile
  92         # will fail if the filename contains non ascii characters unless we
  93         # use a unicode object
  94         path_basename = lambda f: os.path.basename(fn).decode(encoding)
  95         # the same for os.path.dirname
  96         path_dirname = lambda f: os.path.dirname(fn).decode(encoding)
  97     else:
  98         path_basename = os.path.basename
  99         path_dirname = os.path.dirname
 100
 101     args = {
 102         'suffix': '.tmp',
 103         'prefix': path_basename(fn) + '.',
 104         'dir': path_dirname(fn),
 105         'delete': False,
 106     }
 107
 108     # In Python 2.x, json.dump expects a bytestream.
 109     # In Python 3.x, it writes to a character stream
 110     if sys.version_info < (3, 0):
 111         args['mode'] = 'wb'
 112     else:
 113         args.update({
 114             'mode': 'w',
 115             'encoding': 'utf-8',
 116         })
 117
 118     tf = tempfile.NamedTemporaryFile(**compat_kwargs(args))
 119
 120     try:
 121         with tf:
 122             json.dump(obj, tf)
 123         if sys.platform == 'win32':
 124             # Need to remove existing file on Windows, else os.rename raises
 125             # WindowsError or FileExistsError.
 126             try:
 127                 os.unlink(fn)
 128             except OSError:
 129                 pass
 130         os.rename(tf.name, fn)
 131     except Exception:
 132         try:
 133             os.remove(tf.name)
 134         except OSError:
 135             pass
 136         raise
 137
 138
 139 if sys.version_info >= (2, 7):
 140     def find_xpath_attr(node, xpath, key, val):
 141         """ Find the xpath xpath[@key=val] """
 142         assert re.match(r'^[a-zA-Z-]+$', key)
 143         assert re.match(r'^[a-zA-Z0-9@\s:._-]*$', val)
 144         expr = xpath + "[@%s='%s']" % (key, val)
 145         return node.find(expr)
 146 else:
 147     def find_xpath_attr(node, xpath, key, val):
 148         # Here comes the crazy part: In 2.6, if the xpath is a unicode,
 149         # .//node does not match if a node is a direct child of . !
 150         if isinstance(xpath, compat_str):
 151             xpath = xpath.encode('ascii')
 152
 153         for f in node.findall(xpath):
 154             if f.attrib.get(key) == val:
 155                 return f
 156         return None
 157
 158 # On python2.6 the xml.etree.ElementTree.Element methods don't support
 159 # the namespace parameter
 160
 161
 162 def xpath_with_ns(path, ns_map):
 163     components = [c.split(':') for c in path.split('/')]
 164     replaced = []
 165     for c in components:
 166         if len(c) == 1:
 167             replaced.append(c[0])
 168         else:
 169             ns, tag = c
 170             replaced.append('{%s}%s' % (ns_map[ns], tag))
 171     return '/'.join(replaced)
 172
 173
 174 def xpath_text(node, xpath, name=None, fatal=False):
 175     if sys.version_info < (2, 7):  # Crazy 2.6
 176         xpath = xpath.encode('ascii')
 177
 178     n = node.find(xpath)
 179     if n is None or n.text is None:
 180         if fatal:
 181             name = xpath if name is None else name
 182             raise ExtractorError('Could not find XML element %s' % name)
 183         else:
 184             return None
 185     return n.text
 186
 187
 188 def get_element_by_id(id, html):
 189     """Return the content of the tag with the specified ID in the passed HTML document"""
 190     return get_element_by_attribute("id", id, html)
 191
 192
 193 def get_element_by_attribute(attribute, value, html):
 194     """Return the content of the tag with the specified attribute in the passed HTML document"""
 195
 196     m = re.search(r'''(?xs)
 197         <([a-zA-Z0-9:._-]+)
 198          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]+|="[^"]+"|='[^']+'))*?
 199          \s+%s=['"]?%s['"]?
 200          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]+|="[^"]+"|='[^']+'))*?
 201         \s*>
 202         (?P<content>.*?)
 203         </\1>
 204     ''' % (re.escape(attribute), re.escape(value)), html)
 205
 206     if not m:
 207         return None
 208     res = m.group('content')
 209
 210     if res.startswith('"') or res.startswith("'"):
 211         res = res[1:-1]
 212
 213     return unescapeHTML(res)
 214
 215
 216 def clean_html(html):
 217     """Clean an HTML snippet into a readable string"""
 218
 219     if html is None:  # Convenience for sanitizing descriptions etc.
 220         return html
 221
 222     # Newline vs <br />
 223     html = html.replace('\n', ' ')
 224     html = re.sub(r'\s*<\s*br\s*/?\s*>\s*', '\n', html)
 225     html = re.sub(r'<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
 226     # Strip html tags
 227     html = re.sub('<.*?>', '', html)
 228     # Replace html entities
 229     html = unescapeHTML(html)
 230     return html.strip()
 231
 232
 233 def sanitize_open(filename, open_mode):
 234     """Try to open the given filename, and slightly tweak it if this fails.
 235
 236     Attempts to open the given filename. If this fails, it tries to change
 237     the filename slightly, step by step, until it's either able to open it
 238     or it fails and raises a final exception, like the standard open()
 239     function.
 240
 241     It returns the tuple (stream, definitive_file_name).
 242     """
 243     try:
 244         if filename == '-':
 245             if sys.platform == 'win32':
 246                 import msvcrt
 247                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 248             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
 249         stream = open(encodeFilename(filename), open_mode)
 250         return (stream, filename)
 251     except (IOError, OSError) as err:
 252         if err.errno in (errno.EACCES,):
 253             raise
 254
 255         # In case of error, try to remove win32 forbidden chars
 256         alt_filename = sanitize_path(filename)
 257         if alt_filename == filename:
 258             raise
 259         else:
 260             # An exception here should be caught in the caller
 261             stream = open(encodeFilename(alt_filename), open_mode)
 262             return (stream, alt_filename)
 263
 264
 265 def timeconvert(timestr):
 266     """Convert RFC 2822 defined time string into system timestamp"""
 267     timestamp = None
 268     timetuple = email.utils.parsedate_tz(timestr)
 269     if timetuple is not None:
 270         timestamp = email.utils.mktime_tz(timetuple)
 271     return timestamp
 272
 273
 274 def sanitize_filename(s, restricted=False, is_id=False):
 275     """Sanitizes a string so it could be used as part of a filename.
 276     If restricted is set, use a stricter subset of allowed characters.
 277     Set is_id if this is not an arbitrary string, but an ID that should be kept if possible
 278     """
 279     def replace_insane(char):
 280         if char == '?' or ord(char) < 32 or ord(char) == 127:
 281             return ''
 282         elif char == '"':
 283             return '' if restricted else '\''
 284         elif char == ':':
 285             return '_-' if restricted else ' -'
 286         elif char in '\\/|*<>':
 287             return '_'
 288         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
 289             return '_'
 290         if restricted and ord(char) > 127:
 291             return '_'
 292         return char
 293
 294     # Handle timestamps
 295     s = re.sub(r'[0-9]+(?::[0-9]+)+', lambda m: m.group(0).replace(':', '_'), s)
 296     result = ''.join(map(replace_insane, s))
 297     if not is_id:
 298         while '__' in result:
 299             result = result.replace('__', '_')
 300         result = result.strip('_')
 301         # Common case of "Foreign band name - English song title"
 302         if restricted and result.startswith('-_'):
 303             result = result[2:]
 304         if result.startswith('-'):
 305             result = '_' + result[len('-'):]
 306         result = result.lstrip('.')
 307         if not result:
 308             result = '_'
 309     return result
 310
 311
 312 def sanitize_path(s):
 313     """Sanitizes and normalizes path on Windows"""
 314     if sys.platform != 'win32':
 315         return s
 316     drive_or_unc, _ = os.path.splitdrive(s)
 317     if sys.version_info < (2, 7) and not drive_or_unc:
 318         drive_or_unc, _ = os.path.splitunc(s)
 319     norm_path = os.path.normpath(remove_start(s, drive_or_unc)).split(os.path.sep)
 320     if drive_or_unc:
 321         norm_path.pop(0)
 322     sanitized_path = [
 323         path_part if path_part in ['.', '..'] else re.sub('(?:[/<>:"\\|\\\\?\\*]|\.$)', '#', path_part)
 324         for path_part in norm_path]
 325     if drive_or_unc:
 326         sanitized_path.insert(0, drive_or_unc + os.path.sep)
 327     return os.path.join(*sanitized_path)
 328
 329
 330 def orderedSet(iterable):
 331     """ Remove all duplicates from the input iterable """
 332     res = []
 333     for el in iterable:
 334         if el not in res:
 335             res.append(el)
 336     return res
 337
 338
 339 def _htmlentity_transform(entity):
 340     """Transforms an HTML entity to a character."""
 341     # Known non-numeric HTML entity
 342     if entity in compat_html_entities.name2codepoint:
 343         return compat_chr(compat_html_entities.name2codepoint[entity])
 344
 345     mobj = re.match(r'#(x[0-9a-fA-F]+|[0-9]+)', entity)
 346     if mobj is not None:
 347         numstr = mobj.group(1)
 348         if numstr.startswith('x'):
 349             base = 16
 350             numstr = '0%s' % numstr
 351         else:
 352             base = 10
 353         return compat_chr(int(numstr, base))
 354
 355     # Unknown entity in name, return its literal representation
 356     return ('&%s;' % entity)
 357
 358
 359 def unescapeHTML(s):
 360     if s is None:
 361         return None
 362     assert type(s) == compat_str
 363
 364     return re.sub(
 365         r'&([^;]+);', lambda m: _htmlentity_transform(m.group(1)), s)
 366
 367
 368 def get_subprocess_encoding():
 369     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 370         # For subprocess calls, encode with locale encoding
 371         # Refer to http://stackoverflow.com/a/9951851/35070
 372         encoding = preferredencoding()
 373     else:
 374         encoding = sys.getfilesystemencoding()
 375     if encoding is None:
 376         encoding = 'utf-8'
 377     return encoding
 378
 379
 380 def encodeFilename(s, for_subprocess=False):
 381     """
 382     @param s The name of the file
 383     """
 384
 385     assert type(s) == compat_str
 386
 387     # Python 3 has a Unicode API
 388     if sys.version_info >= (3, 0):
 389         return s
 390
 391     # Pass '' directly to use Unicode APIs on Windows 2000 and up
 392     # (Detecting Windows NT 4 is tricky because 'major >= 4' would
 393     # match Windows 9x series as well. Besides, NT 4 is obsolete.)
 394     if not for_subprocess and sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 395         return s
 396
 397     return s.encode(get_subprocess_encoding(), 'ignore')
 398
 399
 400 def decodeFilename(b, for_subprocess=False):
 401
 402     if sys.version_info >= (3, 0):
 403         return b
 404
 405     if not isinstance(b, bytes):
 406         return b
 407
 408     return b.decode(get_subprocess_encoding(), 'ignore')
 409
 410
 411 def encodeArgument(s):
 412     if not isinstance(s, compat_str):
 413         # Legacy code that uses byte strings
 414         # Uncomment the following line after fixing all post processors
 415         # assert False, 'Internal error: %r should be of type %r, is %r' % (s, compat_str, type(s))
 416         s = s.decode('ascii')
 417     return encodeFilename(s, True)
 418
 419
 420 def decodeArgument(b):
 421     return decodeFilename(b, True)
 422
 423
 424 def decodeOption(optval):
 425     if optval is None:
 426         return optval
 427     if isinstance(optval, bytes):
 428         optval = optval.decode(preferredencoding())
 429
 430     assert isinstance(optval, compat_str)
 431     return optval
 432
 433
 434 def formatSeconds(secs):
 435     if secs > 3600:
 436         return '%d:%02d:%02d' % (secs // 3600, (secs % 3600) // 60, secs % 60)
 437     elif secs > 60:
 438         return '%d:%02d' % (secs // 60, secs % 60)
 439     else:
 440         return '%d' % secs
 441
 442
 443 def make_HTTPS_handler(params, **kwargs):
 444     opts_no_check_certificate = params.get('nocheckcertificate', False)
 445     if hasattr(ssl, 'create_default_context'):  # Python >= 3.4 or 2.7.9
 446         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
 447         if opts_no_check_certificate:
 448             context.check_hostname = False
 449             context.verify_mode = ssl.CERT_NONE
 450         try:
 451             return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 452         except TypeError:
 453             # Python 2.7.8
 454             # (create_default_context present but HTTPSHandler has no context=)
 455             pass
 456
 457     if sys.version_info < (3, 2):
 458         return YoutubeDLHTTPSHandler(params, **kwargs)
 459     else:  # Python < 3.4
 460         context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
 461         context.verify_mode = (ssl.CERT_NONE
 462                                if opts_no_check_certificate
 463                                else ssl.CERT_REQUIRED)
 464         context.set_default_verify_paths()
 465         return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 466
 467
 468 def bug_reports_message():
 469     if ytdl_is_updateable():
 470         update_cmd = 'type  youtube-dl -U  to update'
 471     else:
 472         update_cmd = 'see  https://yt-dl.org/update  on how to update'
 473     msg = '; please report this issue on https://yt-dl.org/bug .'
 474     msg += ' Make sure you are using the latest version; %s.' % update_cmd
 475     msg += ' Be sure to call youtube-dl with the --verbose flag and include its complete output.'
 476     return msg
 477
 478
 479 class ExtractorError(Exception):
 480     """Error during info extraction."""
 481
 482     def __init__(self, msg, tb=None, expected=False, cause=None, video_id=None):
 483         """ tb, if given, is the original traceback (so that it can be printed out).
 484         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
 485         """
 486
 487         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
 488             expected = True
 489         if video_id is not None:
 490             msg = video_id + ': ' + msg
 491         if cause:
 492             msg += ' (caused by %r)' % cause
 493         if not expected:
 494             msg += bug_reports_message()
 495         super(ExtractorError, self).__init__(msg)
 496
 497         self.traceback = tb
 498         self.exc_info = sys.exc_info()  # preserve original exception
 499         self.cause = cause
 500         self.video_id = video_id
 501
 502     def format_traceback(self):
 503         if self.traceback is None:
 504             return None
 505         return ''.join(traceback.format_tb(self.traceback))
 506
 507
 508 class UnsupportedError(ExtractorError):
 509     def __init__(self, url):
 510         super(UnsupportedError, self).__init__(
 511             'Unsupported URL: %s' % url, expected=True)
 512         self.url = url
 513
 514
 515 class RegexNotFoundError(ExtractorError):
 516     """Error when a regex didn't match"""
 517     pass
 518
 519
 520 class DownloadError(Exception):
 521     """Download Error exception.
 522
 523     This exception may be thrown by FileDownloader objects if they are not
 524     configured to continue on errors. They will contain the appropriate
 525     error message.
 526     """
 527
 528     def __init__(self, msg, exc_info=None):
 529         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
 530         super(DownloadError, self).__init__(msg)
 531         self.exc_info = exc_info
 532
 533
 534 class SameFileError(Exception):
 535     """Same File exception.
 536
 537     This exception will be thrown by FileDownloader objects if they detect
 538     multiple files would have to be downloaded to the same file on disk.
 539     """
 540     pass
 541
 542
 543 class PostProcessingError(Exception):
 544     """Post Processing exception.
 545
 546     This exception may be raised by PostProcessor's .run() method to
 547     indicate an error in the postprocessing task.
 548     """
 549
 550     def __init__(self, msg):
 551         self.msg = msg
 552
 553
 554 class MaxDownloadsReached(Exception):
 555     """ --max-downloads limit has been reached. """
 556     pass
 557
 558
 559 class UnavailableVideoError(Exception):
 560     """Unavailable Format exception.
 561
 562     This exception will be thrown when a video is requested
 563     in a format that is not available for that video.
 564     """
 565     pass
 566
 567
 568 class ContentTooShortError(Exception):
 569     """Content Too Short exception.
 570
 571     This exception may be raised by FileDownloader objects when a file they
 572     download is too small for what the server announced first, indicating
 573     the connection was probably interrupted.
 574     """
 575     # Both in bytes
 576     downloaded = None
 577     expected = None
 578
 579     def __init__(self, downloaded, expected):
 580         self.downloaded = downloaded
 581         self.expected = expected
 582
 583
 584 def _create_http_connection(ydl_handler, http_class, is_https, *args, **kwargs):
 585     hc = http_class(*args, **kwargs)
 586     source_address = ydl_handler._params.get('source_address')
 587     if source_address is not None:
 588         sa = (source_address, 0)
 589         if hasattr(hc, 'source_address'):  # Python 2.7+
 590             hc.source_address = sa
 591         else:  # Python 2.6
 592             def _hc_connect(self, *args, **kwargs):
 593                 sock = compat_socket_create_connection(
 594                     (self.host, self.port), self.timeout, sa)
 595                 if is_https:
 596                     self.sock = ssl.wrap_socket(
 597                         sock, self.key_file, self.cert_file,
 598                         ssl_version=ssl.PROTOCOL_TLSv1)
 599                 else:
 600                     self.sock = sock
 601             hc.connect = functools.partial(_hc_connect, hc)
 602
 603     return hc
 604
 605
 606 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 607     """Handler for HTTP requests and responses.
 608
 609     This class, when installed with an OpenerDirector, automatically adds
 610     the standard headers to every HTTP request and handles gzipped and
 611     deflated responses from web servers. If compression is to be avoided in
 612     a particular request, the original request in the program code only has
 613     to include the HTTP header "Youtubedl-No-Compression", which will be
 614     removed before making the real request.
 615
 616     Part of this code was copied from:
 617
 618     http://techknack.net/python-urllib2-handlers/
 619
 620     Andrew Rowls, the author of that code, agreed to release it to the
 621     public domain.
 622     """
 623
 624     def __init__(self, params, *args, **kwargs):
 625         compat_urllib_request.HTTPHandler.__init__(self, *args, **kwargs)
 626         self._params = params
 627
 628     def http_open(self, req):
 629         return self.do_open(functools.partial(
 630             _create_http_connection, self, compat_http_client.HTTPConnection, False),
 631             req)
 632
 633     @staticmethod
 634     def deflate(data):
 635         try:
 636             return zlib.decompress(data, -zlib.MAX_WBITS)
 637         except zlib.error:
 638             return zlib.decompress(data)
 639
 640     @staticmethod
 641     def addinfourl_wrapper(stream, headers, url, code):
 642         if hasattr(compat_urllib_request.addinfourl, 'getcode'):
 643             return compat_urllib_request.addinfourl(stream, headers, url, code)
 644         ret = compat_urllib_request.addinfourl(stream, headers, url)
 645         ret.code = code
 646         return ret
 647
 648     def http_request(self, req):
 649         for h, v in std_headers.items():
 650             # Capitalize is needed because of Python bug 2275: http://bugs.python.org/issue2275
 651             # The dict keys are capitalized because of this bug by urllib
 652             if h.capitalize() not in req.headers:
 653                 req.add_header(h, v)
 654         if 'Youtubedl-no-compression' in req.headers:
 655             if 'Accept-encoding' in req.headers:
 656                 del req.headers['Accept-encoding']
 657             del req.headers['Youtubedl-no-compression']
 658
 659         if sys.version_info < (2, 7) and '#' in req.get_full_url():
 660             # Python 2.6 is brain-dead when it comes to fragments
 661             req._Request__original = req._Request__original.partition('#')[0]
 662             req._Request__r_type = req._Request__r_type.partition('#')[0]
 663
 664         return req
 665
 666     def http_response(self, req, resp):
 667         old_resp = resp
 668         # gzip
 669         if resp.headers.get('Content-encoding', '') == 'gzip':
 670             content = resp.read()
 671             gz = gzip.GzipFile(fileobj=io.BytesIO(content), mode='rb')
 672             try:
 673                 uncompressed = io.BytesIO(gz.read())
 674             except IOError as original_ioerror:
 675                 # There may be junk add the end of the file
 676                 # See http://stackoverflow.com/q/4928560/35070 for details
 677                 for i in range(1, 1024):
 678                     try:
 679                         gz = gzip.GzipFile(fileobj=io.BytesIO(content[:-i]), mode='rb')
 680                         uncompressed = io.BytesIO(gz.read())
 681                     except IOError:
 682                         continue
 683                     break
 684                 else:
 685                     raise original_ioerror
 686             resp = self.addinfourl_wrapper(uncompressed, old_resp.headers, old_resp.url, old_resp.code)
 687             resp.msg = old_resp.msg
 688         # deflate
 689         if resp.headers.get('Content-encoding', '') == 'deflate':
 690             gz = io.BytesIO(self.deflate(resp.read()))
 691             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
 692             resp.msg = old_resp.msg
 693         return resp
 694
 695     https_request = http_request
 696     https_response = http_response
 697
 698
 699 class YoutubeDLHTTPSHandler(compat_urllib_request.HTTPSHandler):
 700     def __init__(self, params, https_conn_class=None, *args, **kwargs):
 701         compat_urllib_request.HTTPSHandler.__init__(self, *args, **kwargs)
 702         self._https_conn_class = https_conn_class or compat_http_client.HTTPSConnection
 703         self._params = params
 704
 705     def https_open(self, req):
 706         kwargs = {}
 707         if hasattr(self, '_context'):  # python > 2.6
 708             kwargs['context'] = self._context
 709         if hasattr(self, '_check_hostname'):  # python 3.x
 710             kwargs['check_hostname'] = self._check_hostname
 711         return self.do_open(functools.partial(
 712             _create_http_connection, self, self._https_conn_class, True),
 713             req, **kwargs)
 714
 715
 716 def parse_iso8601(date_str, delimiter='T', timezone=None):
 717     """ Return a UNIX timestamp from the given date """
 718
 719     if date_str is None:
 720         return None
 721
 722     if timezone is None:
 723         m = re.search(
 724             r'(\.[0-9]+)?(?:Z$| ?(?P<sign>\+|-)(?P<hours>[0-9]{2}):?(?P<minutes>[0-9]{2})$)',
 725             date_str)
 726         if not m:
 727             timezone = datetime.timedelta()
 728         else:
 729             date_str = date_str[:-len(m.group(0))]
 730             if not m.group('sign'):
 731                 timezone = datetime.timedelta()
 732             else:
 733                 sign = 1 if m.group('sign') == '+' else -1
 734                 timezone = datetime.timedelta(
 735                     hours=sign * int(m.group('hours')),
 736                     minutes=sign * int(m.group('minutes')))
 737     date_format = '%Y-%m-%d{0}%H:%M:%S'.format(delimiter)
 738     dt = datetime.datetime.strptime(date_str, date_format) - timezone
 739     return calendar.timegm(dt.timetuple())
 740
 741
 742 def unified_strdate(date_str, day_first=True):
 743     """Return a string with the date in the format YYYYMMDD"""
 744
 745     if date_str is None:
 746         return None
 747     upload_date = None
 748     # Replace commas
 749     date_str = date_str.replace(',', ' ')
 750     # %z (UTC offset) is only supported in python>=3.2
 751     if not re.match(r'^[0-9]{1,2}-[0-9]{1,2}-[0-9]{4}$', date_str):
 752         date_str = re.sub(r' ?(\+|-)[0-9]{2}:?[0-9]{2}$', '', date_str)
 753     # Remove AM/PM + timezone
 754     date_str = re.sub(r'(?i)\s*(?:AM|PM)(?:\s+[A-Z]+)?', '', date_str)
 755
 756     format_expressions = [
 757         '%d %B %Y',
 758         '%d %b %Y',
 759         '%B %d %Y',
 760         '%b %d %Y',
 761         '%b %dst %Y %I:%M%p',
 762         '%b %dnd %Y %I:%M%p',
 763         '%b %dth %Y %I:%M%p',
 764         '%Y %m %d',
 765         '%Y-%m-%d',
 766         '%Y/%m/%d',
 767         '%Y/%m/%d %H:%M:%S',
 768         '%Y-%m-%d %H:%M:%S',
 769         '%Y-%m-%d %H:%M:%S.%f',
 770         '%d.%m.%Y %H:%M',
 771         '%d.%m.%Y %H.%M',
 772         '%Y-%m-%dT%H:%M:%SZ',
 773         '%Y-%m-%dT%H:%M:%S.%fZ',
 774         '%Y-%m-%dT%H:%M:%S.%f0Z',
 775         '%Y-%m-%dT%H:%M:%S',
 776         '%Y-%m-%dT%H:%M:%S.%f',
 777         '%Y-%m-%dT%H:%M',
 778     ]
 779     if day_first:
 780         format_expressions.extend([
 781             '%d-%m-%Y',
 782             '%d.%m.%Y',
 783             '%d/%m/%Y',
 784             '%d/%m/%y',
 785             '%d/%m/%Y %H:%M:%S',
 786         ])
 787     else:
 788         format_expressions.extend([
 789             '%m-%d-%Y',
 790             '%m.%d.%Y',
 791             '%m/%d/%Y',
 792             '%m/%d/%y',
 793             '%m/%d/%Y %H:%M:%S',
 794         ])
 795     for expression in format_expressions:
 796         try:
 797             upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
 798         except ValueError:
 799             pass
 800     if upload_date is None:
 801         timetuple = email.utils.parsedate_tz(date_str)
 802         if timetuple:
 803             upload_date = datetime.datetime(*timetuple[:6]).strftime('%Y%m%d')
 804     return upload_date
 805
 806
 807 def determine_ext(url, default_ext='unknown_video'):
 808     if url is None:
 809         return default_ext
 810     guess = url.partition('?')[0].rpartition('.')[2]
 811     if re.match(r'^[A-Za-z0-9]+$', guess):
 812         return guess
 813     else:
 814         return default_ext
 815
 816
 817 def subtitles_filename(filename, sub_lang, sub_format):
 818     return filename.rsplit('.', 1)[0] + '.' + sub_lang + '.' + sub_format
 819
 820
 821 def date_from_str(date_str):
 822     """
 823     Return a datetime object from a string in the format YYYYMMDD or
 824     (now|today)[+-][0-9](day|week|month|year)(s)?"""
 825     today = datetime.date.today()
 826     if date_str in ('now', 'today'):
 827         return today
 828     if date_str == 'yesterday':
 829         return today - datetime.timedelta(days=1)
 830     match = re.match('(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
 831     if match is not None:
 832         sign = match.group('sign')
 833         time = int(match.group('time'))
 834         if sign == '-':
 835             time = -time
 836         unit = match.group('unit')
 837         # A bad aproximation?
 838         if unit == 'month':
 839             unit = 'day'
 840             time *= 30
 841         elif unit == 'year':
 842             unit = 'day'
 843             time *= 365
 844         unit += 's'
 845         delta = datetime.timedelta(**{unit: time})
 846         return today + delta
 847     return datetime.datetime.strptime(date_str, "%Y%m%d").date()
 848
 849
 850 def hyphenate_date(date_str):
 851     """
 852     Convert a date in 'YYYYMMDD' format to 'YYYY-MM-DD' format"""
 853     match = re.match(r'^(\d\d\d\d)(\d\d)(\d\d)$', date_str)
 854     if match is not None:
 855         return '-'.join(match.groups())
 856     else:
 857         return date_str
 858
 859
 860 class DateRange(object):
 861     """Represents a time interval between two dates"""
 862
 863     def __init__(self, start=None, end=None):
 864         """start and end must be strings in the format accepted by date"""
 865         if start is not None:
 866             self.start = date_from_str(start)
 867         else:
 868             self.start = datetime.datetime.min.date()
 869         if end is not None:
 870             self.end = date_from_str(end)
 871         else:
 872             self.end = datetime.datetime.max.date()
 873         if self.start > self.end:
 874             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
 875
 876     @classmethod
 877     def day(cls, day):
 878         """Returns a range that only contains the given day"""
 879         return cls(day, day)
 880
 881     def __contains__(self, date):
 882         """Check if the date is in the range"""
 883         if not isinstance(date, datetime.date):
 884             date = date_from_str(date)
 885         return self.start <= date <= self.end
 886
 887     def __str__(self):
 888         return '%s - %s' % (self.start.isoformat(), self.end.isoformat())
 889
 890
 891 def platform_name():
 892     """ Returns the platform name as a compat_str """
 893     res = platform.platform()
 894     if isinstance(res, bytes):
 895         res = res.decode(preferredencoding())
 896
 897     assert isinstance(res, compat_str)
 898     return res
 899
 900
 901 def _windows_write_string(s, out):
 902     """ Returns True if the string was written using special methods,
 903     False if it has yet to be written out."""
 904     # Adapted from http://stackoverflow.com/a/3259271/35070
 905
 906     import ctypes
 907     import ctypes.wintypes
 908
 909     WIN_OUTPUT_IDS = {
 910         1: -11,
 911         2: -12,
 912     }
 913
 914     try:
 915         fileno = out.fileno()
 916     except AttributeError:
 917         # If the output stream doesn't have a fileno, it's virtual
 918         return False
 919     except io.UnsupportedOperation:
 920         # Some strange Windows pseudo files?
 921         return False
 922     if fileno not in WIN_OUTPUT_IDS:
 923         return False
 924
 925     GetStdHandle = ctypes.WINFUNCTYPE(
 926         ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD)(
 927         (b"GetStdHandle", ctypes.windll.kernel32))
 928     h = GetStdHandle(WIN_OUTPUT_IDS[fileno])
 929
 930     WriteConsoleW = ctypes.WINFUNCTYPE(
 931         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE, ctypes.wintypes.LPWSTR,
 932         ctypes.wintypes.DWORD, ctypes.POINTER(ctypes.wintypes.DWORD),
 933         ctypes.wintypes.LPVOID)((b"WriteConsoleW", ctypes.windll.kernel32))
 934     written = ctypes.wintypes.DWORD(0)
 935
 936     GetFileType = ctypes.WINFUNCTYPE(ctypes.wintypes.DWORD, ctypes.wintypes.DWORD)((b"GetFileType", ctypes.windll.kernel32))
 937     FILE_TYPE_CHAR = 0x0002
 938     FILE_TYPE_REMOTE = 0x8000
 939     GetConsoleMode = ctypes.WINFUNCTYPE(
 940         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE,
 941         ctypes.POINTER(ctypes.wintypes.DWORD))(
 942         (b"GetConsoleMode", ctypes.windll.kernel32))
 943     INVALID_HANDLE_VALUE = ctypes.wintypes.DWORD(-1).value
 944
 945     def not_a_console(handle):
 946         if handle == INVALID_HANDLE_VALUE or handle is None:
 947             return True
 948         return ((GetFileType(handle) & ~FILE_TYPE_REMOTE) != FILE_TYPE_CHAR or
 949                 GetConsoleMode(handle, ctypes.byref(ctypes.wintypes.DWORD())) == 0)
 950
 951     if not_a_console(h):
 952         return False
 953
 954     def next_nonbmp_pos(s):
 955         try:
 956             return next(i for i, c in enumerate(s) if ord(c) > 0xffff)
 957         except StopIteration:
 958             return len(s)
 959
 960     while s:
 961         count = min(next_nonbmp_pos(s), 1024)
 962
 963         ret = WriteConsoleW(
 964             h, s, count if count else 2, ctypes.byref(written), None)
 965         if ret == 0:
 966             raise OSError('Failed to write string')
 967         if not count:  # We just wrote a non-BMP character
 968             assert written.value == 2
 969             s = s[1:]
 970         else:
 971             assert written.value > 0
 972             s = s[written.value:]
 973     return True
 974
 975
 976 def write_string(s, out=None, encoding=None):
 977     if out is None:
 978         out = sys.stderr
 979     assert type(s) == compat_str
 980
 981     if sys.platform == 'win32' and encoding is None and hasattr(out, 'fileno'):
 982         if _windows_write_string(s, out):
 983             return
 984
 985     if ('b' in getattr(out, 'mode', '') or
 986             sys.version_info[0] < 3):  # Python 2 lies about mode of sys.stderr
 987         byt = s.encode(encoding or preferredencoding(), 'ignore')
 988         out.write(byt)
 989     elif hasattr(out, 'buffer'):
 990         enc = encoding or getattr(out, 'encoding', None) or preferredencoding()
 991         byt = s.encode(enc, 'ignore')
 992         out.buffer.write(byt)
 993     else:
 994         out.write(s)
 995     out.flush()
 996
 997
 998 def bytes_to_intlist(bs):
 999     if not bs:
1000         return []
1001     if isinstance(bs[0], int):  # Python 3
1002         return list(bs)
1003     else:
1004         return [ord(c) for c in bs]
1005
1006
1007 def intlist_to_bytes(xs):
1008     if not xs:
1009         return b''
1010     return struct_pack('%dB' % len(xs), *xs)
1011
1012
1013 # Cross-platform file locking
1014 if sys.platform == 'win32':
1015     import ctypes.wintypes
1016     import msvcrt
1017
1018     class OVERLAPPED(ctypes.Structure):
1019         _fields_ = [
1020             ('Internal', ctypes.wintypes.LPVOID),
1021             ('InternalHigh', ctypes.wintypes.LPVOID),
1022             ('Offset', ctypes.wintypes.DWORD),
1023             ('OffsetHigh', ctypes.wintypes.DWORD),
1024             ('hEvent', ctypes.wintypes.HANDLE),
1025         ]
1026
1027     kernel32 = ctypes.windll.kernel32
1028     LockFileEx = kernel32.LockFileEx
1029     LockFileEx.argtypes = [
1030         ctypes.wintypes.HANDLE,     # hFile
1031         ctypes.wintypes.DWORD,      # dwFlags
1032         ctypes.wintypes.DWORD,      # dwReserved
1033         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1034         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1035         ctypes.POINTER(OVERLAPPED)  # Overlapped
1036     ]
1037     LockFileEx.restype = ctypes.wintypes.BOOL
1038     UnlockFileEx = kernel32.UnlockFileEx
1039     UnlockFileEx.argtypes = [
1040         ctypes.wintypes.HANDLE,     # hFile
1041         ctypes.wintypes.DWORD,      # dwReserved
1042         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1043         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1044         ctypes.POINTER(OVERLAPPED)  # Overlapped
1045     ]
1046     UnlockFileEx.restype = ctypes.wintypes.BOOL
1047     whole_low = 0xffffffff
1048     whole_high = 0x7fffffff
1049
1050     def _lock_file(f, exclusive):
1051         overlapped = OVERLAPPED()
1052         overlapped.Offset = 0
1053         overlapped.OffsetHigh = 0
1054         overlapped.hEvent = 0
1055         f._lock_file_overlapped_p = ctypes.pointer(overlapped)
1056         handle = msvcrt.get_osfhandle(f.fileno())
1057         if not LockFileEx(handle, 0x2 if exclusive else 0x0, 0,
1058                           whole_low, whole_high, f._lock_file_overlapped_p):
1059             raise OSError('Locking file failed: %r' % ctypes.FormatError())
1060
1061     def _unlock_file(f):
1062         assert f._lock_file_overlapped_p
1063         handle = msvcrt.get_osfhandle(f.fileno())
1064         if not UnlockFileEx(handle, 0,
1065                             whole_low, whole_high, f._lock_file_overlapped_p):
1066             raise OSError('Unlocking file failed: %r' % ctypes.FormatError())
1067
1068 else:
1069     import fcntl
1070
1071     def _lock_file(f, exclusive):
1072         fcntl.flock(f, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
1073
1074     def _unlock_file(f):
1075         fcntl.flock(f, fcntl.LOCK_UN)
1076
1077
1078 class locked_file(object):
1079     def __init__(self, filename, mode, encoding=None):
1080         assert mode in ['r', 'a', 'w']
1081         self.f = io.open(filename, mode, encoding=encoding)
1082         self.mode = mode
1083
1084     def __enter__(self):
1085         exclusive = self.mode != 'r'
1086         try:
1087             _lock_file(self.f, exclusive)
1088         except IOError:
1089             self.f.close()
1090             raise
1091         return self
1092
1093     def __exit__(self, etype, value, traceback):
1094         try:
1095             _unlock_file(self.f)
1096         finally:
1097             self.f.close()
1098
1099     def __iter__(self):
1100         return iter(self.f)
1101
1102     def write(self, *args):
1103         return self.f.write(*args)
1104
1105     def read(self, *args):
1106         return self.f.read(*args)
1107
1108
1109 def get_filesystem_encoding():
1110     encoding = sys.getfilesystemencoding()
1111     return encoding if encoding is not None else 'utf-8'
1112
1113
1114 def shell_quote(args):
1115     quoted_args = []
1116     encoding = get_filesystem_encoding()
1117     for a in args:
1118         if isinstance(a, bytes):
1119             # We may get a filename encoded with 'encodeFilename'
1120             a = a.decode(encoding)
1121         quoted_args.append(pipes.quote(a))
1122     return ' '.join(quoted_args)
1123
1124
1125 def smuggle_url(url, data):
1126     """ Pass additional data in a URL for internal use. """
1127
1128     sdata = compat_urllib_parse.urlencode(
1129         {'__youtubedl_smuggle': json.dumps(data)})
1130     return url + '#' + sdata
1131
1132
1133 def unsmuggle_url(smug_url, default=None):
1134     if '#__youtubedl_smuggle' not in smug_url:
1135         return smug_url, default
1136     url, _, sdata = smug_url.rpartition('#')
1137     jsond = compat_parse_qs(sdata)['__youtubedl_smuggle'][0]
1138     data = json.loads(jsond)
1139     return url, data
1140
1141
1142 def format_bytes(bytes):
1143     if bytes is None:
1144         return 'N/A'
1145     if type(bytes) is str:
1146         bytes = float(bytes)
1147     if bytes == 0.0:
1148         exponent = 0
1149     else:
1150         exponent = int(math.log(bytes, 1024.0))
1151     suffix = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'][exponent]
1152     converted = float(bytes) / float(1024 ** exponent)
1153     return '%.2f%s' % (converted, suffix)
1154
1155
1156 def parse_filesize(s):
1157     if s is None:
1158         return None
1159
1160     # The lower-case forms are of course incorrect and inofficial,
1161     # but we support those too
1162     _UNIT_TABLE = {
1163         'B': 1,
1164         'b': 1,
1165         'KiB': 1024,
1166         'KB': 1000,
1167         'kB': 1024,
1168         'Kb': 1000,
1169         'MiB': 1024 ** 2,
1170         'MB': 1000 ** 2,
1171         'mB': 1024 ** 2,
1172         'Mb': 1000 ** 2,
1173         'GiB': 1024 ** 3,
1174         'GB': 1000 ** 3,
1175         'gB': 1024 ** 3,
1176         'Gb': 1000 ** 3,
1177         'TiB': 1024 ** 4,
1178         'TB': 1000 ** 4,
1179         'tB': 1024 ** 4,
1180         'Tb': 1000 ** 4,
1181         'PiB': 1024 ** 5,
1182         'PB': 1000 ** 5,
1183         'pB': 1024 ** 5,
1184         'Pb': 1000 ** 5,
1185         'EiB': 1024 ** 6,
1186         'EB': 1000 ** 6,
1187         'eB': 1024 ** 6,
1188         'Eb': 1000 ** 6,
1189         'ZiB': 1024 ** 7,
1190         'ZB': 1000 ** 7,
1191         'zB': 1024 ** 7,
1192         'Zb': 1000 ** 7,
1193         'YiB': 1024 ** 8,
1194         'YB': 1000 ** 8,
1195         'yB': 1024 ** 8,
1196         'Yb': 1000 ** 8,
1197     }
1198
1199     units_re = '|'.join(re.escape(u) for u in _UNIT_TABLE)
1200     m = re.match(
1201         r'(?P<num>[0-9]+(?:[,.][0-9]*)?)\s*(?P<unit>%s)' % units_re, s)
1202     if not m:
1203         return None
1204
1205     num_str = m.group('num').replace(',', '.')
1206     mult = _UNIT_TABLE[m.group('unit')]
1207     return int(float(num_str) * mult)
1208
1209
1210 def month_by_name(name):
1211     """ Return the number of a month by (locale-independently) English name """
1212
1213     try:
1214         return ENGLISH_MONTH_NAMES.index(name) + 1
1215     except ValueError:
1216         return None
1217
1218
1219 def month_by_abbreviation(abbrev):
1220     """ Return the number of a month by (locale-independently) English
1221         abbreviations """
1222
1223     try:
1224         return [s[:3] for s in ENGLISH_MONTH_NAMES].index(abbrev) + 1
1225     except ValueError:
1226         return None
1227
1228
1229 def fix_xml_ampersands(xml_str):
1230     """Replace all the '&' by '&amp;' in XML"""
1231     return re.sub(
1232         r'&(?!amp;|lt;|gt;|apos;|quot;|#x[0-9a-fA-F]{,4};|#[0-9]{,4};)',
1233         '&amp;',
1234         xml_str)
1235
1236
1237 def setproctitle(title):
1238     assert isinstance(title, compat_str)
1239     try:
1240         libc = ctypes.cdll.LoadLibrary("libc.so.6")
1241     except OSError:
1242         return
1243     title_bytes = title.encode('utf-8')
1244     buf = ctypes.create_string_buffer(len(title_bytes))
1245     buf.value = title_bytes
1246     try:
1247         libc.prctl(15, buf, 0, 0, 0)
1248     except AttributeError:
1249         return  # Strange libc, just skip this
1250
1251
1252 def remove_start(s, start):
1253     if s.startswith(start):
1254         return s[len(start):]
1255     return s
1256
1257
1258 def remove_end(s, end):
1259     if s.endswith(end):
1260         return s[:-len(end)]
1261     return s
1262
1263
1264 def url_basename(url):
1265     path = compat_urlparse.urlparse(url).path
1266     return path.strip('/').split('/')[-1]
1267
1268
1269 class HEADRequest(compat_urllib_request.Request):
1270     def get_method(self):
1271         return "HEAD"
1272
1273
1274 def int_or_none(v, scale=1, default=None, get_attr=None, invscale=1):
1275     if get_attr:
1276         if v is not None:
1277             v = getattr(v, get_attr, None)
1278     if v == '':
1279         v = None
1280     return default if v is None else (int(v) * invscale // scale)
1281
1282
1283 def str_or_none(v, default=None):
1284     return default if v is None else compat_str(v)
1285
1286
1287 def str_to_int(int_str):
1288     """ A more relaxed version of int_or_none """
1289     if int_str is None:
1290         return None
1291     int_str = re.sub(r'[,\.\+]', '', int_str)
1292     return int(int_str)
1293
1294
1295 def float_or_none(v, scale=1, invscale=1, default=None):
1296     return default if v is None else (float(v) * invscale / scale)
1297
1298
1299 def parse_duration(s):
1300     if not isinstance(s, compat_basestring):
1301         return None
1302
1303     s = s.strip()
1304
1305     m = re.match(
1306         r'''(?ix)(?:P?T)?
1307         (?:
1308             (?P<only_mins>[0-9.]+)\s*(?:mins?|minutes?)\s*|
1309             (?P<only_hours>[0-9.]+)\s*(?:hours?)|
1310
1311             \s*(?P<hours_reversed>[0-9]+)\s*(?:[:h]|hours?)\s*(?P<mins_reversed>[0-9]+)\s*(?:[:m]|mins?|minutes?)\s*|
1312             (?:
1313                 (?:
1314                     (?:(?P<days>[0-9]+)\s*(?:[:d]|days?)\s*)?
1315                     (?P<hours>[0-9]+)\s*(?:[:h]|hours?)\s*
1316                 )?
1317                 (?P<mins>[0-9]+)\s*(?:[:m]|mins?|minutes?)\s*
1318             )?
1319             (?P<secs>[0-9]+)(?P<ms>\.[0-9]+)?\s*(?:s|secs?|seconds?)?
1320         )$''', s)
1321     if not m:
1322         return None
1323     res = 0
1324     if m.group('only_mins'):
1325         return float_or_none(m.group('only_mins'), invscale=60)
1326     if m.group('only_hours'):
1327         return float_or_none(m.group('only_hours'), invscale=60 * 60)
1328     if m.group('secs'):
1329         res += int(m.group('secs'))
1330     if m.group('mins_reversed'):
1331         res += int(m.group('mins_reversed')) * 60
1332     if m.group('mins'):
1333         res += int(m.group('mins')) * 60
1334     if m.group('hours'):
1335         res += int(m.group('hours')) * 60 * 60
1336     if m.group('hours_reversed'):
1337         res += int(m.group('hours_reversed')) * 60 * 60
1338     if m.group('days'):
1339         res += int(m.group('days')) * 24 * 60 * 60
1340     if m.group('ms'):
1341         res += float(m.group('ms'))
1342     return res
1343
1344
1345 def prepend_extension(filename, ext, expected_real_ext=None):
1346     name, real_ext = os.path.splitext(filename)
1347     return (
1348         '{0}.{1}{2}'.format(name, ext, real_ext)
1349         if not expected_real_ext or real_ext[1:] == expected_real_ext
1350         else '{0}.{1}'.format(filename, ext))
1351
1352
1353 def replace_extension(filename, ext, expected_real_ext=None):
1354     name, real_ext = os.path.splitext(filename)
1355     return '{0}.{1}'.format(
1356         name if not expected_real_ext or real_ext[1:] == expected_real_ext else filename,
1357         ext)
1358
1359
1360 def check_executable(exe, args=[]):
1361     """ Checks if the given binary is installed somewhere in PATH, and returns its name.
1362     args can be a list of arguments for a short output (like -version) """
1363     try:
1364         subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
1365     except OSError:
1366         return False
1367     return exe
1368
1369
1370 def get_exe_version(exe, args=['--version'],
1371                     version_re=None, unrecognized='present'):
1372     """ Returns the version of the specified executable,
1373     or False if the executable is not present """
1374     try:
1375         out, _ = subprocess.Popen(
1376             [encodeArgument(exe)] + args,
1377             stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate()
1378     except OSError:
1379         return False
1380     if isinstance(out, bytes):  # Python 2.x
1381         out = out.decode('ascii', 'ignore')
1382     return detect_exe_version(out, version_re, unrecognized)
1383
1384
1385 def detect_exe_version(output, version_re=None, unrecognized='present'):
1386     assert isinstance(output, compat_str)
1387     if version_re is None:
1388         version_re = r'version\s+([-0-9._a-zA-Z]+)'
1389     m = re.search(version_re, output)
1390     if m:
1391         return m.group(1)
1392     else:
1393         return unrecognized
1394
1395
1396 class PagedList(object):
1397     def __len__(self):
1398         # This is only useful for tests
1399         return len(self.getslice())
1400
1401
1402 class OnDemandPagedList(PagedList):
1403     def __init__(self, pagefunc, pagesize):
1404         self._pagefunc = pagefunc
1405         self._pagesize = pagesize
1406
1407     def getslice(self, start=0, end=None):
1408         res = []
1409         for pagenum in itertools.count(start // self._pagesize):
1410             firstid = pagenum * self._pagesize
1411             nextfirstid = pagenum * self._pagesize + self._pagesize
1412             if start >= nextfirstid:
1413                 continue
1414
1415             page_results = list(self._pagefunc(pagenum))
1416
1417             startv = (
1418                 start % self._pagesize
1419                 if firstid <= start < nextfirstid
1420                 else 0)
1421
1422             endv = (
1423                 ((end - 1) % self._pagesize) + 1
1424                 if (end is not None and firstid <= end <= nextfirstid)
1425                 else None)
1426
1427             if startv != 0 or endv is not None:
1428                 page_results = page_results[startv:endv]
1429             res.extend(page_results)
1430
1431             # A little optimization - if current page is not "full", ie. does
1432             # not contain page_size videos then we can assume that this page
1433             # is the last one - there are no more ids on further pages -
1434             # i.e. no need to query again.
1435             if len(page_results) + startv < self._pagesize:
1436                 break
1437
1438             # If we got the whole page, but the next page is not interesting,
1439             # break out early as well
1440             if end == nextfirstid:
1441                 break
1442         return res
1443
1444
1445 class InAdvancePagedList(PagedList):
1446     def __init__(self, pagefunc, pagecount, pagesize):
1447         self._pagefunc = pagefunc
1448         self._pagecount = pagecount
1449         self._pagesize = pagesize
1450
1451     def getslice(self, start=0, end=None):
1452         res = []
1453         start_page = start // self._pagesize
1454         end_page = (
1455             self._pagecount if end is None else (end // self._pagesize + 1))
1456         skip_elems = start - start_page * self._pagesize
1457         only_more = None if end is None else end - start
1458         for pagenum in range(start_page, end_page):
1459             page = list(self._pagefunc(pagenum))
1460             if skip_elems:
1461                 page = page[skip_elems:]
1462                 skip_elems = None
1463             if only_more is not None:
1464                 if len(page) < only_more:
1465                     only_more -= len(page)
1466                 else:
1467                     page = page[:only_more]
1468                     res.extend(page)
1469                     break
1470             res.extend(page)
1471         return res
1472
1473
1474 def uppercase_escape(s):
1475     unicode_escape = codecs.getdecoder('unicode_escape')
1476     return re.sub(
1477         r'\\U[0-9a-fA-F]{8}',
1478         lambda m: unicode_escape(m.group(0))[0],
1479         s)
1480
1481
1482 def lowercase_escape(s):
1483     unicode_escape = codecs.getdecoder('unicode_escape')
1484     return re.sub(
1485         r'\\u[0-9a-fA-F]{4}',
1486         lambda m: unicode_escape(m.group(0))[0],
1487         s)
1488
1489
1490 def escape_rfc3986(s):
1491     """Escape non-ASCII characters as suggested by RFC 3986"""
1492     if sys.version_info < (3, 0) and isinstance(s, compat_str):
1493         s = s.encode('utf-8')
1494     return compat_urllib_parse.quote(s, b"%/;:@&=+$,!~*'()?#[]")
1495
1496
1497 def escape_url(url):
1498     """Escape URL as suggested by RFC 3986"""
1499     url_parsed = compat_urllib_parse_urlparse(url)
1500     return url_parsed._replace(
1501         path=escape_rfc3986(url_parsed.path),
1502         params=escape_rfc3986(url_parsed.params),
1503         query=escape_rfc3986(url_parsed.query),
1504         fragment=escape_rfc3986(url_parsed.fragment)
1505     ).geturl()
1506
1507 try:
1508     struct.pack('!I', 0)
1509 except TypeError:
1510     # In Python 2.6 (and some 2.7 versions), struct requires a bytes argument
1511     def struct_pack(spec, *args):
1512         if isinstance(spec, compat_str):
1513             spec = spec.encode('ascii')
1514         return struct.pack(spec, *args)
1515
1516     def struct_unpack(spec, *args):
1517         if isinstance(spec, compat_str):
1518             spec = spec.encode('ascii')
1519         return struct.unpack(spec, *args)
1520 else:
1521     struct_pack = struct.pack
1522     struct_unpack = struct.unpack
1523
1524
1525 def read_batch_urls(batch_fd):
1526     def fixup(url):
1527         if not isinstance(url, compat_str):
1528             url = url.decode('utf-8', 'replace')
1529         BOM_UTF8 = '\xef\xbb\xbf'
1530         if url.startswith(BOM_UTF8):
1531             url = url[len(BOM_UTF8):]
1532         url = url.strip()
1533         if url.startswith(('#', ';', ']')):
1534             return False
1535         return url
1536
1537     with contextlib.closing(batch_fd) as fd:
1538         return [url for url in map(fixup, fd) if url]
1539
1540
1541 def urlencode_postdata(*args, **kargs):
1542     return compat_urllib_parse.urlencode(*args, **kargs).encode('ascii')
1543
1544
1545 try:
1546     etree_iter = xml.etree.ElementTree.Element.iter
1547 except AttributeError:  # Python <=2.6
1548     etree_iter = lambda n: n.findall('.//*')
1549
1550
1551 def parse_xml(s):
1552     class TreeBuilder(xml.etree.ElementTree.TreeBuilder):
1553         def doctype(self, name, pubid, system):
1554             pass  # Ignore doctypes
1555
1556     parser = xml.etree.ElementTree.XMLParser(target=TreeBuilder())
1557     kwargs = {'parser': parser} if sys.version_info >= (2, 7) else {}
1558     tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
1559     # Fix up XML parser in Python 2.x
1560     if sys.version_info < (3, 0):
1561         for n in etree_iter(tree):
1562             if n.text is not None:
1563                 if not isinstance(n.text, compat_str):
1564                     n.text = n.text.decode('utf-8')
1565     return tree
1566
1567
1568 US_RATINGS = {
1569     'G': 0,
1570     'PG': 10,
1571     'PG-13': 13,
1572     'R': 16,
1573     'NC': 18,
1574 }
1575
1576
1577 def parse_age_limit(s):
1578     if s is None:
1579         return None
1580     m = re.match(r'^(?P<age>\d{1,2})\+?$', s)
1581     return int(m.group('age')) if m else US_RATINGS.get(s, None)
1582
1583
1584 def strip_jsonp(code):
1585     return re.sub(
1586         r'(?s)^[a-zA-Z0-9_]+\s*\(\s*(.*)\);?\s*?(?://[^\n]*)*$', r'\1', code)
1587
1588
1589 def js_to_json(code):
1590     def fix_kv(m):
1591         v = m.group(0)
1592         if v in ('true', 'false', 'null'):
1593             return v
1594         if v.startswith('"'):
1595             return v
1596         if v.startswith("'"):
1597             v = v[1:-1]
1598             v = re.sub(r"\\\\|\\'|\"", lambda m: {
1599                 '\\\\': '\\\\',
1600                 "\\'": "'",
1601                 '"': '\\"',
1602             }[m.group(0)], v)
1603         return '"%s"' % v
1604
1605     res = re.sub(r'''(?x)
1606         "(?:[^"\\]*(?:\\\\|\\['"nu]))*[^"\\]*"|
1607         '(?:[^'\\]*(?:\\\\|\\['"nu]))*[^'\\]*'|
1608         [a-zA-Z_][.a-zA-Z_0-9]*
1609         ''', fix_kv, code)
1610     res = re.sub(r',(\s*[\]}])', lambda m: m.group(1), res)
1611     return res
1612
1613
1614 def qualities(quality_ids):
1615     """ Get a numeric quality value out of a list of possible values """
1616     def q(qid):
1617         try:
1618             return quality_ids.index(qid)
1619         except ValueError:
1620             return -1
1621     return q
1622
1623
1624 DEFAULT_OUTTMPL = '%(title)s-%(id)s.%(ext)s'
1625
1626
1627 def limit_length(s, length):
1628     """ Add ellipses to overly long strings """
1629     if s is None:
1630         return None
1631     ELLIPSES = '...'
1632     if len(s) > length:
1633         return s[:length - len(ELLIPSES)] + ELLIPSES
1634     return s
1635
1636
1637 def version_tuple(v):
1638     return tuple(int(e) for e in re.split(r'[-.]', v))
1639
1640
1641 def is_outdated_version(version, limit, assume_new=True):
1642     if not version:
1643         return not assume_new
1644     try:
1645         return version_tuple(version) < version_tuple(limit)
1646     except ValueError:
1647         return not assume_new
1648
1649
1650 def ytdl_is_updateable():
1651     """ Returns if youtube-dl can be updated with -U """
1652     from zipimport import zipimporter
1653
1654     return isinstance(globals().get('__loader__'), zipimporter) or hasattr(sys, 'frozen')
1655
1656
1657 def args_to_str(args):
1658     # Get a short string representation for a subprocess command
1659     return ' '.join(shlex_quote(a) for a in args)
1660
1661
1662 def mimetype2ext(mt):
1663     _, _, res = mt.rpartition('/')
1664
1665     return {
1666         'x-ms-wmv': 'wmv',
1667         'x-mp4-fragmented': 'mp4',
1668         'ttml+xml': 'ttml',
1669     }.get(res, res)
1670
1671
1672 def urlhandle_detect_ext(url_handle):
1673     try:
1674         url_handle.headers
1675         getheader = lambda h: url_handle.headers[h]
1676     except AttributeError:  # Python < 3
1677         getheader = url_handle.info().getheader
1678
1679     cd = getheader('Content-Disposition')
1680     if cd:
1681         m = re.match(r'attachment;\s*filename="(?P<filename>[^"]+)"', cd)
1682         if m:
1683             e = determine_ext(m.group('filename'), default_ext=None)
1684             if e:
1685                 return e
1686
1687     return mimetype2ext(getheader('Content-Type'))
1688
1689
1690 def age_restricted(content_limit, age_limit):
1691     """ Returns True iff the content should be blocked """
1692
1693     if age_limit is None:  # No limit set
1694         return False
1695     if content_limit is None:
1696         return False  # Content available for everyone
1697     return age_limit < content_limit
1698
1699
1700 def is_html(first_bytes):
1701     """ Detect whether a file contains HTML by examining its first bytes. """
1702
1703     BOMS = [
1704         (b'\xef\xbb\xbf', 'utf-8'),
1705         (b'\x00\x00\xfe\xff', 'utf-32-be'),
1706         (b'\xff\xfe\x00\x00', 'utf-32-le'),
1707         (b'\xff\xfe', 'utf-16-le'),
1708         (b'\xfe\xff', 'utf-16-be'),
1709     ]
1710     for bom, enc in BOMS:
1711         if first_bytes.startswith(bom):
1712             s = first_bytes[len(bom):].decode(enc, 'replace')
1713             break
1714     else:
1715         s = first_bytes.decode('utf-8', 'replace')
1716
1717     return re.match(r'^\s*<', s)
1718
1719
1720 def determine_protocol(info_dict):
1721     protocol = info_dict.get('protocol')
1722     if protocol is not None:
1723         return protocol
1724
1725     url = info_dict['url']
1726     if url.startswith('rtmp'):
1727         return 'rtmp'
1728     elif url.startswith('mms'):
1729         return 'mms'
1730     elif url.startswith('rtsp'):
1731         return 'rtsp'
1732
1733     ext = determine_ext(url)
1734     if ext == 'm3u8':
1735         return 'm3u8'
1736     elif ext == 'f4m':
1737         return 'f4m'
1738
1739     return compat_urllib_parse_urlparse(url).scheme
1740
1741
1742 def render_table(header_row, data):
1743     """ Render a list of rows, each as a list of values """
1744     table = [header_row] + data
1745     max_lens = [max(len(compat_str(v)) for v in col) for col in zip(*table)]
1746     format_str = ' '.join('%-' + compat_str(ml + 1) + 's' for ml in max_lens[:-1]) + '%s'
1747     return '\n'.join(format_str % tuple(row) for row in table)
1748
1749
1750 def _match_one(filter_part, dct):
1751     COMPARISON_OPERATORS = {
1752         '<': operator.lt,
1753         '<=': operator.le,
1754         '>': operator.gt,
1755         '>=': operator.ge,
1756         '=': operator.eq,
1757         '!=': operator.ne,
1758     }
1759     operator_rex = re.compile(r'''(?x)\s*
1760         (?P<key>[a-z_]+)
1761         \s*(?P<op>%s)(?P<none_inclusive>\s*\?)?\s*
1762         (?:
1763             (?P<intval>[0-9.]+(?:[kKmMgGtTpPeEzZyY]i?[Bb]?)?)|
1764             (?P<strval>(?![0-9.])[a-z0-9A-Z]*)
1765         )
1766         \s*$
1767         ''' % '|'.join(map(re.escape, COMPARISON_OPERATORS.keys())))
1768     m = operator_rex.search(filter_part)
1769     if m:
1770         op = COMPARISON_OPERATORS[m.group('op')]
1771         if m.group('strval') is not None:
1772             if m.group('op') not in ('=', '!='):
1773                 raise ValueError(
1774                     'Operator %s does not support string values!' % m.group('op'))
1775             comparison_value = m.group('strval')
1776         else:
1777             try:
1778                 comparison_value = int(m.group('intval'))
1779             except ValueError:
1780                 comparison_value = parse_filesize(m.group('intval'))
1781                 if comparison_value is None:
1782                     comparison_value = parse_filesize(m.group('intval') + 'B')
1783                 if comparison_value is None:
1784                     raise ValueError(
1785                         'Invalid integer value %r in filter part %r' % (
1786                             m.group('intval'), filter_part))
1787         actual_value = dct.get(m.group('key'))
1788         if actual_value is None:
1789             return m.group('none_inclusive')
1790         return op(actual_value, comparison_value)
1791
1792     UNARY_OPERATORS = {
1793         '': lambda v: v is not None,
1794         '!': lambda v: v is None,
1795     }
1796     operator_rex = re.compile(r'''(?x)\s*
1797         (?P<op>%s)\s*(?P<key>[a-z_]+)
1798         \s*$
1799         ''' % '|'.join(map(re.escape, UNARY_OPERATORS.keys())))
1800     m = operator_rex.search(filter_part)
1801     if m:
1802         op = UNARY_OPERATORS[m.group('op')]
1803         actual_value = dct.get(m.group('key'))
1804         return op(actual_value)
1805
1806     raise ValueError('Invalid filter part %r' % filter_part)
1807
1808
1809 def match_str(filter_str, dct):
1810     """ Filter a dictionary with a simple string syntax. Returns True (=passes filter) or false """
1811
1812     return all(
1813         _match_one(filter_part, dct) for filter_part in filter_str.split('&'))
1814
1815
1816 def match_filter_func(filter_str):
1817     def _match_func(info_dict):
1818         if match_str(filter_str, info_dict):
1819             return None
1820         else:
1821             video_title = info_dict.get('title', info_dict.get('id', 'video'))
1822             return '%s does not pass filter %s, skipping ..' % (video_title, filter_str)
1823     return _match_func
1824
1825
1826 def parse_dfxp_time_expr(time_expr):
1827     if not time_expr:
1828         return 0.0
1829
1830     mobj = re.match(r'^(?P<time_offset>\d+(?:\.\d+)?)s?$', time_expr)
1831     if mobj:
1832         return float(mobj.group('time_offset'))
1833
1834     mobj = re.match(r'^(\d+):(\d\d):(\d\d(?:\.\d+)?)$', time_expr)
1835     if mobj:
1836         return 3600 * int(mobj.group(1)) + 60 * int(mobj.group(2)) + float(mobj.group(3))
1837
1838
1839 def srt_subtitles_timecode(seconds):
1840     return '%02d:%02d:%02d,%03d' % (seconds / 3600, (seconds % 3600) / 60, seconds % 60, (seconds % 1) * 1000)
1841
1842
1843 def dfxp2srt(dfxp_data):
1844     _x = functools.partial(xpath_with_ns, ns_map={'ttml': 'http://www.w3.org/ns/ttml'})
1845
1846     def parse_node(node):
1847         str_or_empty = functools.partial(str_or_none, default='')
1848
1849         out = str_or_empty(node.text)
1850
1851         for child in node:
1852             if child.tag in (_x('ttml:br'), 'br'):
1853                 out += '\n' + str_or_empty(child.tail)
1854             elif child.tag in (_x('ttml:span'), 'span'):
1855                 out += str_or_empty(parse_node(child))
1856             else:
1857                 out += str_or_empty(xml.etree.ElementTree.tostring(child))
1858
1859         return out
1860
1861     dfxp = xml.etree.ElementTree.fromstring(dfxp_data.encode('utf-8'))
1862     out = []
1863     paras = dfxp.findall(_x('.//ttml:p')) or dfxp.findall('.//p')
1864
1865     if not paras:
1866         raise ValueError('Invalid dfxp/TTML subtitle')
1867
1868     for para, index in zip(paras, itertools.count(1)):
1869         begin_time = parse_dfxp_time_expr(para.attrib['begin'])
1870         end_time = parse_dfxp_time_expr(para.attrib.get('end'))
1871         if not end_time:
1872             end_time = begin_time + parse_dfxp_time_expr(para.attrib['dur'])
1873         out.append('%d\n%s --> %s\n%s\n\n' % (
1874             index,
1875             srt_subtitles_timecode(begin_time),
1876             srt_subtitles_timecode(end_time),
1877             parse_node(para)))
1878
1879     return ''.join(out)
1880
1881
1882 class PerRequestProxyHandler(compat_urllib_request.ProxyHandler):
1883     def __init__(self, proxies=None):
1884         # Set default handlers
1885         for type in ('http', 'https'):
1886             setattr(self, '%s_open' % type,
1887                     lambda r, proxy='__noproxy__', type=type, meth=self.proxy_open:
1888                         meth(r, proxy, type))
1889         return compat_urllib_request.ProxyHandler.__init__(self, proxies)
1890
1891     def proxy_open(self, req, proxy, type):
1892         req_proxy = req.headers.get('Ytdl-request-proxy')
1893         if req_proxy is not None:
1894             proxy = req_proxy
1895             del req.headers['Ytdl-request-proxy']
1896
1897         if proxy == '__noproxy__':
1898             return None  # No Proxy
1899         return compat_urllib_request.ProxyHandler.proxy_open(
1900             self, req, proxy, type)