youtube_dl/utils.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 import ctypes
   5 import datetime
   6 import email.utils
   7 import errno
   8 import gzip
   9 import itertools
  10 import io
  11 import json
  12 import locale
  13 import math
  14 import os
  15 import pipes
  16 import platform
  17 import re
  18 import ssl
  19 import socket
  20 import subprocess
  21 import sys
  22 import traceback
  23 import zlib
  24
  25 try:
  26     import urllib.request as compat_urllib_request
  27 except ImportError: # Python 2
  28     import urllib2 as compat_urllib_request
  29
  30 try:
  31     import urllib.error as compat_urllib_error
  32 except ImportError: # Python 2
  33     import urllib2 as compat_urllib_error
  34
  35 try:
  36     import urllib.parse as compat_urllib_parse
  37 except ImportError: # Python 2
  38     import urllib as compat_urllib_parse
  39
  40 try:
  41     from urllib.parse import urlparse as compat_urllib_parse_urlparse
  42 except ImportError: # Python 2
  43     from urlparse import urlparse as compat_urllib_parse_urlparse
  44
  45 try:
  46     import urllib.parse as compat_urlparse
  47 except ImportError: # Python 2
  48     import urlparse as compat_urlparse
  49
  50 try:
  51     import http.cookiejar as compat_cookiejar
  52 except ImportError: # Python 2
  53     import cookielib as compat_cookiejar
  54
  55 try:
  56     import html.entities as compat_html_entities
  57 except ImportError: # Python 2
  58     import htmlentitydefs as compat_html_entities
  59
  60 try:
  61     import html.parser as compat_html_parser
  62 except ImportError: # Python 2
  63     import HTMLParser as compat_html_parser
  64
  65 try:
  66     import http.client as compat_http_client
  67 except ImportError: # Python 2
  68     import httplib as compat_http_client
  69
  70 try:
  71     from urllib.error import HTTPError as compat_HTTPError
  72 except ImportError:  # Python 2
  73     from urllib2 import HTTPError as compat_HTTPError
  74
  75 try:
  76     from urllib.request import urlretrieve as compat_urlretrieve
  77 except ImportError:  # Python 2
  78     from urllib import urlretrieve as compat_urlretrieve
  79
  80
  81 try:
  82     from subprocess import DEVNULL
  83     compat_subprocess_get_DEVNULL = lambda: DEVNULL
  84 except ImportError:
  85     compat_subprocess_get_DEVNULL = lambda: open(os.path.devnull, 'w')
  86
  87 try:
  88     from urllib.parse import parse_qs as compat_parse_qs
  89 except ImportError: # Python 2
  90     # HACK: The following is the correct parse_qs implementation from cpython 3's stdlib.
  91     # Python 2's version is apparently totally broken
  92     def _unquote(string, encoding='utf-8', errors='replace'):
  93         if string == '':
  94             return string
  95         res = string.split('%')
  96         if len(res) == 1:
  97             return string
  98         if encoding is None:
  99             encoding = 'utf-8'
 100         if errors is None:
 101             errors = 'replace'
 102         # pct_sequence: contiguous sequence of percent-encoded bytes, decoded
 103         pct_sequence = b''
 104         string = res[0]
 105         for item in res[1:]:
 106             try:
 107                 if not item:
 108                     raise ValueError
 109                 pct_sequence += item[:2].decode('hex')
 110                 rest = item[2:]
 111                 if not rest:
 112                     # This segment was just a single percent-encoded character.
 113                     # May be part of a sequence of code units, so delay decoding.
 114                     # (Stored in pct_sequence).
 115                     continue
 116             except ValueError:
 117                 rest = '%' + item
 118             # Encountered non-percent-encoded characters. Flush the current
 119             # pct_sequence.
 120             string += pct_sequence.decode(encoding, errors) + rest
 121             pct_sequence = b''
 122         if pct_sequence:
 123             # Flush the final pct_sequence
 124             string += pct_sequence.decode(encoding, errors)
 125         return string
 126
 127     def _parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 128                 encoding='utf-8', errors='replace'):
 129         qs, _coerce_result = qs, unicode
 130         pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
 131         r = []
 132         for name_value in pairs:
 133             if not name_value and not strict_parsing:
 134                 continue
 135             nv = name_value.split('=', 1)
 136             if len(nv) != 2:
 137                 if strict_parsing:
 138                     raise ValueError("bad query field: %r" % (name_value,))
 139                 # Handle case of a control-name with no equal sign
 140                 if keep_blank_values:
 141                     nv.append('')
 142                 else:
 143                     continue
 144             if len(nv[1]) or keep_blank_values:
 145                 name = nv[0].replace('+', ' ')
 146                 name = _unquote(name, encoding=encoding, errors=errors)
 147                 name = _coerce_result(name)
 148                 value = nv[1].replace('+', ' ')
 149                 value = _unquote(value, encoding=encoding, errors=errors)
 150                 value = _coerce_result(value)
 151                 r.append((name, value))
 152         return r
 153
 154     def compat_parse_qs(qs, keep_blank_values=False, strict_parsing=False,
 155                 encoding='utf-8', errors='replace'):
 156         parsed_result = {}
 157         pairs = _parse_qsl(qs, keep_blank_values, strict_parsing,
 158                         encoding=encoding, errors=errors)
 159         for name, value in pairs:
 160             if name in parsed_result:
 161                 parsed_result[name].append(value)
 162             else:
 163                 parsed_result[name] = [value]
 164         return parsed_result
 165
 166 try:
 167     compat_str = unicode # Python 2
 168 except NameError:
 169     compat_str = str
 170
 171 try:
 172     compat_chr = unichr # Python 2
 173 except NameError:
 174     compat_chr = chr
 175
 176 def compat_ord(c):
 177     if type(c) is int: return c
 178     else: return ord(c)
 179
 180 # This is not clearly defined otherwise
 181 compiled_regex_type = type(re.compile(''))
 182
 183 std_headers = {
 184     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0 (Chrome)',
 185     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
 186     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 187     'Accept-Encoding': 'gzip, deflate',
 188     'Accept-Language': 'en-us,en;q=0.5',
 189 }
 190
 191 def preferredencoding():
 192     """Get preferred encoding.
 193
 194     Returns the best encoding scheme for the system, based on
 195     locale.getpreferredencoding() and some further tweaks.
 196     """
 197     try:
 198         pref = locale.getpreferredencoding()
 199         u'TEST'.encode(pref)
 200     except:
 201         pref = 'UTF-8'
 202
 203     return pref
 204
 205 if sys.version_info < (3,0):
 206     def compat_print(s):
 207         print(s.encode(preferredencoding(), 'xmlcharrefreplace'))
 208 else:
 209     def compat_print(s):
 210         assert type(s) == type(u'')
 211         print(s)
 212
 213 # In Python 2.x, json.dump expects a bytestream.
 214 # In Python 3.x, it writes to a character stream
 215 if sys.version_info < (3,0):
 216     def write_json_file(obj, fn):
 217         with open(fn, 'wb') as f:
 218             json.dump(obj, f)
 219 else:
 220     def write_json_file(obj, fn):
 221         with open(fn, 'w', encoding='utf-8') as f:
 222             json.dump(obj, f)
 223
 224 if sys.version_info >= (2,7):
 225     def find_xpath_attr(node, xpath, key, val):
 226         """ Find the xpath xpath[@key=val] """
 227         assert re.match(r'^[a-zA-Z]+$', key)
 228         assert re.match(r'^[a-zA-Z0-9@\s:._]*$', val)
 229         expr = xpath + u"[@%s='%s']" % (key, val)
 230         return node.find(expr)
 231 else:
 232     def find_xpath_attr(node, xpath, key, val):
 233         for f in node.findall(xpath):
 234             if f.attrib.get(key) == val:
 235                 return f
 236         return None
 237
 238 # On python2.6 the xml.etree.ElementTree.Element methods don't support
 239 # the namespace parameter
 240 def xpath_with_ns(path, ns_map):
 241     components = [c.split(':') for c in path.split('/')]
 242     replaced = []
 243     for c in components:
 244         if len(c) == 1:
 245             replaced.append(c[0])
 246         else:
 247             ns, tag = c
 248             replaced.append('{%s}%s' % (ns_map[ns], tag))
 249     return '/'.join(replaced)
 250
 251 def htmlentity_transform(matchobj):
 252     """Transforms an HTML entity to a character.
 253
 254     This function receives a match object and is intended to be used with
 255     the re.sub() function.
 256     """
 257     entity = matchobj.group(1)
 258
 259     # Known non-numeric HTML entity
 260     if entity in compat_html_entities.name2codepoint:
 261         return compat_chr(compat_html_entities.name2codepoint[entity])
 262
 263     mobj = re.match(u'(?u)#(x?\\d+)', entity)
 264     if mobj is not None:
 265         numstr = mobj.group(1)
 266         if numstr.startswith(u'x'):
 267             base = 16
 268             numstr = u'0%s' % numstr
 269         else:
 270             base = 10
 271         return compat_chr(int(numstr, base))
 272
 273     # Unknown entity in name, return its literal representation
 274     return (u'&%s;' % entity)
 275
 276 compat_html_parser.locatestarttagend = re.compile(r"""<[a-zA-Z][-.a-zA-Z0-9:_]*(?:\s+(?:(?<=['"\s])[^\s/>][^\s/=>]*(?:\s*=+\s*(?:'[^']*'|"[^"]*"|(?!['"])[^>\s]*))?\s*)*)?\s*""", re.VERBOSE) # backport bugfix
 277 class BaseHTMLParser(compat_html_parser.HTMLParser):
 278     def __init(self):
 279         compat_html_parser.HTMLParser.__init__(self)
 280         self.html = None
 281
 282     def loads(self, html):
 283         self.html = html
 284         self.feed(html)
 285         self.close()
 286
 287 class AttrParser(BaseHTMLParser):
 288     """Modified HTMLParser that isolates a tag with the specified attribute"""
 289     def __init__(self, attribute, value):
 290         self.attribute = attribute
 291         self.value = value
 292         self.result = None
 293         self.started = False
 294         self.depth = {}
 295         self.watch_startpos = False
 296         self.error_count = 0
 297         BaseHTMLParser.__init__(self)
 298
 299     def error(self, message):
 300         if self.error_count > 10 or self.started:
 301             raise compat_html_parser.HTMLParseError(message, self.getpos())
 302         self.rawdata = '\n'.join(self.html.split('\n')[self.getpos()[0]:]) # skip one line
 303         self.error_count += 1
 304         self.goahead(1)
 305
 306     def handle_starttag(self, tag, attrs):
 307         attrs = dict(attrs)
 308         if self.started:
 309             self.find_startpos(None)
 310         if self.attribute in attrs and attrs[self.attribute] == self.value:
 311             self.result = [tag]
 312             self.started = True
 313             self.watch_startpos = True
 314         if self.started:
 315             if not tag in self.depth: self.depth[tag] = 0
 316             self.depth[tag] += 1
 317
 318     def handle_endtag(self, tag):
 319         if self.started:
 320             if tag in self.depth: self.depth[tag] -= 1
 321             if self.depth[self.result[0]] == 0:
 322                 self.started = False
 323                 self.result.append(self.getpos())
 324
 325     def find_startpos(self, x):
 326         """Needed to put the start position of the result (self.result[1])
 327         after the opening tag with the requested id"""
 328         if self.watch_startpos:
 329             self.watch_startpos = False
 330             self.result.append(self.getpos())
 331     handle_entityref = handle_charref = handle_data = handle_comment = \
 332     handle_decl = handle_pi = unknown_decl = find_startpos
 333
 334     def get_result(self):
 335         if self.result is None:
 336             return None
 337         if len(self.result) != 3:
 338             return None
 339         lines = self.html.split('\n')
 340         lines = lines[self.result[1][0]-1:self.result[2][0]]
 341         lines[0] = lines[0][self.result[1][1]:]
 342         if len(lines) == 1:
 343             lines[-1] = lines[-1][:self.result[2][1]-self.result[1][1]]
 344         lines[-1] = lines[-1][:self.result[2][1]]
 345         return '\n'.join(lines).strip()
 346 # Hack for https://github.com/rg3/youtube-dl/issues/662
 347 if sys.version_info < (2, 7, 3):
 348     AttrParser.parse_endtag = (lambda self, i:
 349         i + len("</scr'+'ipt>")
 350         if self.rawdata[i:].startswith("</scr'+'ipt>")
 351         else compat_html_parser.HTMLParser.parse_endtag(self, i))
 352
 353 def get_element_by_id(id, html):
 354     """Return the content of the tag with the specified ID in the passed HTML document"""
 355     return get_element_by_attribute("id", id, html)
 356
 357 def get_element_by_attribute(attribute, value, html):
 358     """Return the content of the tag with the specified attribute in the passed HTML document"""
 359     parser = AttrParser(attribute, value)
 360     try:
 361         parser.loads(html)
 362     except compat_html_parser.HTMLParseError:
 363         pass
 364     return parser.get_result()
 365
 366 class MetaParser(BaseHTMLParser):
 367     """
 368     Modified HTMLParser that isolates a meta tag with the specified name
 369     attribute.
 370     """
 371     def __init__(self, name):
 372         BaseHTMLParser.__init__(self)
 373         self.name = name
 374         self.content = None
 375         self.result = None
 376
 377     def handle_starttag(self, tag, attrs):
 378         if tag != 'meta':
 379             return
 380         attrs = dict(attrs)
 381         if attrs.get('name') == self.name:
 382             self.result = attrs.get('content')
 383
 384     def get_result(self):
 385         return self.result
 386
 387 def get_meta_content(name, html):
 388     """
 389     Return the content attribute from the meta tag with the given name attribute.
 390     """
 391     parser = MetaParser(name)
 392     try:
 393         parser.loads(html)
 394     except compat_html_parser.HTMLParseError:
 395         pass
 396     return parser.get_result()
 397
 398
 399 def clean_html(html):
 400     """Clean an HTML snippet into a readable string"""
 401     # Newline vs <br />
 402     html = html.replace('\n', ' ')
 403     html = re.sub(r'\s*<\s*br\s*/?\s*>\s*', '\n', html)
 404     html = re.sub(r'<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
 405     # Strip html tags
 406     html = re.sub('<.*?>', '', html)
 407     # Replace html entities
 408     html = unescapeHTML(html)
 409     return html.strip()
 410
 411
 412 def sanitize_open(filename, open_mode):
 413     """Try to open the given filename, and slightly tweak it if this fails.
 414
 415     Attempts to open the given filename. If this fails, it tries to change
 416     the filename slightly, step by step, until it's either able to open it
 417     or it fails and raises a final exception, like the standard open()
 418     function.
 419
 420     It returns the tuple (stream, definitive_file_name).
 421     """
 422     try:
 423         if filename == u'-':
 424             if sys.platform == 'win32':
 425                 import msvcrt
 426                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 427             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
 428         stream = open(encodeFilename(filename), open_mode)
 429         return (stream, filename)
 430     except (IOError, OSError) as err:
 431         if err.errno in (errno.EACCES,):
 432             raise
 433
 434         # In case of error, try to remove win32 forbidden chars
 435         alt_filename = os.path.join(
 436                         re.sub(u'[/<>:"\\|\\\\?\\*]', u'#', path_part)
 437                         for path_part in os.path.split(filename)
 438                        )
 439         if alt_filename == filename:
 440             raise
 441         else:
 442             # An exception here should be caught in the caller
 443             stream = open(encodeFilename(filename), open_mode)
 444             return (stream, alt_filename)
 445
 446
 447 def timeconvert(timestr):
 448     """Convert RFC 2822 defined time string into system timestamp"""
 449     timestamp = None
 450     timetuple = email.utils.parsedate_tz(timestr)
 451     if timetuple is not None:
 452         timestamp = email.utils.mktime_tz(timetuple)
 453     return timestamp
 454
 455 def sanitize_filename(s, restricted=False, is_id=False):
 456     """Sanitizes a string so it could be used as part of a filename.
 457     If restricted is set, use a stricter subset of allowed characters.
 458     Set is_id if this is not an arbitrary string, but an ID that should be kept if possible
 459     """
 460     def replace_insane(char):
 461         if char == '?' or ord(char) < 32 or ord(char) == 127:
 462             return ''
 463         elif char == '"':
 464             return '' if restricted else '\''
 465         elif char == ':':
 466             return '_-' if restricted else ' -'
 467         elif char in '\\/|*<>':
 468             return '_'
 469         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
 470             return '_'
 471         if restricted and ord(char) > 127:
 472             return '_'
 473         return char
 474
 475     result = u''.join(map(replace_insane, s))
 476     if not is_id:
 477         while '__' in result:
 478             result = result.replace('__', '_')
 479         result = result.strip('_')
 480         # Common case of "Foreign band name - English song title"
 481         if restricted and result.startswith('-_'):
 482             result = result[2:]
 483         if not result:
 484             result = '_'
 485     return result
 486
 487 def orderedSet(iterable):
 488     """ Remove all duplicates from the input iterable """
 489     res = []
 490     for el in iterable:
 491         if el not in res:
 492             res.append(el)
 493     return res
 494
 495 def unescapeHTML(s):
 496     """
 497     @param s a string
 498     """
 499     assert type(s) == type(u'')
 500
 501     result = re.sub(u'(?u)&(.+?);', htmlentity_transform, s)
 502     return result
 503
 504
 505 def encodeFilename(s, for_subprocess=False):
 506     """
 507     @param s The name of the file
 508     """
 509
 510     assert type(s) == compat_str
 511
 512     # Python 3 has a Unicode API
 513     if sys.version_info >= (3, 0):
 514         return s
 515
 516     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 517         # Pass u'' directly to use Unicode APIs on Windows 2000 and up
 518         # (Detecting Windows NT 4 is tricky because 'major >= 4' would
 519         # match Windows 9x series as well. Besides, NT 4 is obsolete.)
 520         if not for_subprocess:
 521             return s
 522         else:
 523             # For subprocess calls, encode with locale encoding
 524             # Refer to http://stackoverflow.com/a/9951851/35070
 525             encoding = preferredencoding()
 526     else:
 527         encoding = sys.getfilesystemencoding()
 528     if encoding is None:
 529         encoding = 'utf-8'
 530     return s.encode(encoding, 'ignore')
 531
 532
 533 def decodeOption(optval):
 534     if optval is None:
 535         return optval
 536     if isinstance(optval, bytes):
 537         optval = optval.decode(preferredencoding())
 538
 539     assert isinstance(optval, compat_str)
 540     return optval
 541
 542 def formatSeconds(secs):
 543     if secs > 3600:
 544         return '%d:%02d:%02d' % (secs // 3600, (secs % 3600) // 60, secs % 60)
 545     elif secs > 60:
 546         return '%d:%02d' % (secs // 60, secs % 60)
 547     else:
 548         return '%d' % secs
 549
 550
 551 def make_HTTPS_handler(opts_no_check_certificate, **kwargs):
 552     if sys.version_info < (3, 2):
 553         import httplib
 554
 555         class HTTPSConnectionV3(httplib.HTTPSConnection):
 556             def __init__(self, *args, **kwargs):
 557                 httplib.HTTPSConnection.__init__(self, *args, **kwargs)
 558
 559             def connect(self):
 560                 sock = socket.create_connection((self.host, self.port), self.timeout)
 561                 if getattr(self, '_tunnel_host', False):
 562                     self.sock = sock
 563                     self._tunnel()
 564                 try:
 565                     self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_SSLv3)
 566                 except ssl.SSLError:
 567                     self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_SSLv23)
 568
 569         class HTTPSHandlerV3(compat_urllib_request.HTTPSHandler):
 570             def https_open(self, req):
 571                 return self.do_open(HTTPSConnectionV3, req)
 572         return HTTPSHandlerV3(**kwargs)
 573     else:
 574         context = ssl.SSLContext(ssl.PROTOCOL_SSLv3)
 575         context.verify_mode = (ssl.CERT_NONE
 576                                if opts_no_check_certificate
 577                                else ssl.CERT_REQUIRED)
 578         context.set_default_verify_paths()
 579         try:
 580             context.load_default_certs()
 581         except AttributeError:
 582             pass  # Python < 3.4
 583         return compat_urllib_request.HTTPSHandler(context=context, **kwargs)
 584
 585 class ExtractorError(Exception):
 586     """Error during info extraction."""
 587     def __init__(self, msg, tb=None, expected=False, cause=None):
 588         """ tb, if given, is the original traceback (so that it can be printed out).
 589         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
 590         """
 591
 592         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
 593             expected = True
 594         if not expected:
 595             msg = msg + u'; please report this issue on https://yt-dl.org/bug . Be sure to call youtube-dl with the --verbose flag and include its complete output. Make sure you are using the latest version; type  youtube-dl -U  to update.'
 596         super(ExtractorError, self).__init__(msg)
 597
 598         self.traceback = tb
 599         self.exc_info = sys.exc_info()  # preserve original exception
 600         self.cause = cause
 601
 602     def format_traceback(self):
 603         if self.traceback is None:
 604             return None
 605         return u''.join(traceback.format_tb(self.traceback))
 606
 607
 608 class RegexNotFoundError(ExtractorError):
 609     """Error when a regex didn't match"""
 610     pass
 611
 612
 613 class DownloadError(Exception):
 614     """Download Error exception.
 615
 616     This exception may be thrown by FileDownloader objects if they are not
 617     configured to continue on errors. They will contain the appropriate
 618     error message.
 619     """
 620     def __init__(self, msg, exc_info=None):
 621         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
 622         super(DownloadError, self).__init__(msg)
 623         self.exc_info = exc_info
 624
 625
 626 class SameFileError(Exception):
 627     """Same File exception.
 628
 629     This exception will be thrown by FileDownloader objects if they detect
 630     multiple files would have to be downloaded to the same file on disk.
 631     """
 632     pass
 633
 634
 635 class PostProcessingError(Exception):
 636     """Post Processing exception.
 637
 638     This exception may be raised by PostProcessor's .run() method to
 639     indicate an error in the postprocessing task.
 640     """
 641     def __init__(self, msg):
 642         self.msg = msg
 643
 644 class MaxDownloadsReached(Exception):
 645     """ --max-downloads limit has been reached. """
 646     pass
 647
 648
 649 class UnavailableVideoError(Exception):
 650     """Unavailable Format exception.
 651
 652     This exception will be thrown when a video is requested
 653     in a format that is not available for that video.
 654     """
 655     pass
 656
 657
 658 class ContentTooShortError(Exception):
 659     """Content Too Short exception.
 660
 661     This exception may be raised by FileDownloader objects when a file they
 662     download is too small for what the server announced first, indicating
 663     the connection was probably interrupted.
 664     """
 665     # Both in bytes
 666     downloaded = None
 667     expected = None
 668
 669     def __init__(self, downloaded, expected):
 670         self.downloaded = downloaded
 671         self.expected = expected
 672
 673 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 674     """Handler for HTTP requests and responses.
 675
 676     This class, when installed with an OpenerDirector, automatically adds
 677     the standard headers to every HTTP request and handles gzipped and
 678     deflated responses from web servers. If compression is to be avoided in
 679     a particular request, the original request in the program code only has
 680     to include the HTTP header "Youtubedl-No-Compression", which will be
 681     removed before making the real request.
 682
 683     Part of this code was copied from:
 684
 685     http://techknack.net/python-urllib2-handlers/
 686
 687     Andrew Rowls, the author of that code, agreed to release it to the
 688     public domain.
 689     """
 690
 691     @staticmethod
 692     def deflate(data):
 693         try:
 694             return zlib.decompress(data, -zlib.MAX_WBITS)
 695         except zlib.error:
 696             return zlib.decompress(data)
 697
 698     @staticmethod
 699     def addinfourl_wrapper(stream, headers, url, code):
 700         if hasattr(compat_urllib_request.addinfourl, 'getcode'):
 701             return compat_urllib_request.addinfourl(stream, headers, url, code)
 702         ret = compat_urllib_request.addinfourl(stream, headers, url)
 703         ret.code = code
 704         return ret
 705
 706     def http_request(self, req):
 707         for h,v in std_headers.items():
 708             if h in req.headers:
 709                 del req.headers[h]
 710             req.add_header(h, v)
 711         if 'Youtubedl-no-compression' in req.headers:
 712             if 'Accept-encoding' in req.headers:
 713                 del req.headers['Accept-encoding']
 714             del req.headers['Youtubedl-no-compression']
 715         if 'Youtubedl-user-agent' in req.headers:
 716             if 'User-agent' in req.headers:
 717                 del req.headers['User-agent']
 718             req.headers['User-agent'] = req.headers['Youtubedl-user-agent']
 719             del req.headers['Youtubedl-user-agent']
 720         return req
 721
 722     def http_response(self, req, resp):
 723         old_resp = resp
 724         # gzip
 725         if resp.headers.get('Content-encoding', '') == 'gzip':
 726             content = resp.read()
 727             gz = gzip.GzipFile(fileobj=io.BytesIO(content), mode='rb')
 728             try:
 729                 uncompressed = io.BytesIO(gz.read())
 730             except IOError as original_ioerror:
 731                 # There may be junk add the end of the file
 732                 # See http://stackoverflow.com/q/4928560/35070 for details
 733                 for i in range(1, 1024):
 734                     try:
 735                         gz = gzip.GzipFile(fileobj=io.BytesIO(content[:-i]), mode='rb')
 736                         uncompressed = io.BytesIO(gz.read())
 737                     except IOError:
 738                         continue
 739                     break
 740                 else:
 741                     raise original_ioerror
 742             resp = self.addinfourl_wrapper(uncompressed, old_resp.headers, old_resp.url, old_resp.code)
 743             resp.msg = old_resp.msg
 744         # deflate
 745         if resp.headers.get('Content-encoding', '') == 'deflate':
 746             gz = io.BytesIO(self.deflate(resp.read()))
 747             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
 748             resp.msg = old_resp.msg
 749         return resp
 750
 751     https_request = http_request
 752     https_response = http_response
 753
 754 def unified_strdate(date_str):
 755     """Return a string with the date in the format YYYYMMDD"""
 756     upload_date = None
 757     #Replace commas
 758     date_str = date_str.replace(',',' ')
 759     # %z (UTC offset) is only supported in python>=3.2
 760     date_str = re.sub(r' (\+|-)[\d]*$', '', date_str)
 761     format_expressions = [
 762         '%d %B %Y',
 763         '%B %d %Y',
 764         '%b %d %Y',
 765         '%Y-%m-%d',
 766         '%d/%m/%Y',
 767         '%Y/%m/%d %H:%M:%S',
 768         '%Y-%m-%d %H:%M:%S',
 769         '%d.%m.%Y %H:%M',
 770         '%Y-%m-%dT%H:%M:%SZ',
 771         '%Y-%m-%dT%H:%M:%S.%fZ',
 772         '%Y-%m-%dT%H:%M:%S.%f0Z',
 773         '%Y-%m-%dT%H:%M:%S',
 774     ]
 775     for expression in format_expressions:
 776         try:
 777             upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
 778         except:
 779             pass
 780     if upload_date is None:
 781         timetuple = email.utils.parsedate_tz(date_str)
 782         if timetuple:
 783             upload_date = datetime.datetime(*timetuple[:6]).strftime('%Y%m%d')
 784     return upload_date
 785
 786 def determine_ext(url, default_ext=u'unknown_video'):
 787     guess = url.partition(u'?')[0].rpartition(u'.')[2]
 788     if re.match(r'^[A-Za-z0-9]+$', guess):
 789         return guess
 790     else:
 791         return default_ext
 792
 793 def subtitles_filename(filename, sub_lang, sub_format):
 794     return filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
 795
 796 def date_from_str(date_str):
 797     """
 798     Return a datetime object from a string in the format YYYYMMDD or
 799     (now|today)[+-][0-9](day|week|month|year)(s)?"""
 800     today = datetime.date.today()
 801     if date_str == 'now'or date_str == 'today':
 802         return today
 803     match = re.match('(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
 804     if match is not None:
 805         sign = match.group('sign')
 806         time = int(match.group('time'))
 807         if sign == '-':
 808             time = -time
 809         unit = match.group('unit')
 810         #A bad aproximation?
 811         if unit == 'month':
 812             unit = 'day'
 813             time *= 30
 814         elif unit == 'year':
 815             unit = 'day'
 816             time *= 365
 817         unit += 's'
 818         delta = datetime.timedelta(**{unit: time})
 819         return today + delta
 820     return datetime.datetime.strptime(date_str, "%Y%m%d").date()
 821
 822 def hyphenate_date(date_str):
 823     """
 824     Convert a date in 'YYYYMMDD' format to 'YYYY-MM-DD' format"""
 825     match = re.match(r'^(\d\d\d\d)(\d\d)(\d\d)$', date_str)
 826     if match is not None:
 827         return '-'.join(match.groups())
 828     else:
 829         return date_str
 830
 831 class DateRange(object):
 832     """Represents a time interval between two dates"""
 833     def __init__(self, start=None, end=None):
 834         """start and end must be strings in the format accepted by date"""
 835         if start is not None:
 836             self.start = date_from_str(start)
 837         else:
 838             self.start = datetime.datetime.min.date()
 839         if end is not None:
 840             self.end = date_from_str(end)
 841         else:
 842             self.end = datetime.datetime.max.date()
 843         if self.start > self.end:
 844             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
 845     @classmethod
 846     def day(cls, day):
 847         """Returns a range that only contains the given day"""
 848         return cls(day,day)
 849     def __contains__(self, date):
 850         """Check if the date is in the range"""
 851         if not isinstance(date, datetime.date):
 852             date = date_from_str(date)
 853         return self.start <= date <= self.end
 854     def __str__(self):
 855         return '%s - %s' % ( self.start.isoformat(), self.end.isoformat())
 856
 857
 858 def platform_name():
 859     """ Returns the platform name as a compat_str """
 860     res = platform.platform()
 861     if isinstance(res, bytes):
 862         res = res.decode(preferredencoding())
 863
 864     assert isinstance(res, compat_str)
 865     return res
 866
 867
 868 def write_string(s, out=None):
 869     if out is None:
 870         out = sys.stderr
 871     assert type(s) == compat_str
 872
 873     if ('b' in getattr(out, 'mode', '') or
 874             sys.version_info[0] < 3):  # Python 2 lies about mode of sys.stderr
 875         s = s.encode(preferredencoding(), 'ignore')
 876     try:
 877         out.write(s)
 878     except UnicodeEncodeError:
 879         # In Windows shells, this can fail even when the codec is just charmap!?
 880         # See https://wiki.python.org/moin/PrintFails#Issue
 881         if sys.platform == 'win32' and hasattr(out, 'encoding'):
 882             s = s.encode(out.encoding, 'ignore').decode(out.encoding)
 883             out.write(s)
 884         else:
 885             raise
 886
 887     out.flush()
 888
 889
 890 def bytes_to_intlist(bs):
 891     if not bs:
 892         return []
 893     if isinstance(bs[0], int):  # Python 3
 894         return list(bs)
 895     else:
 896         return [ord(c) for c in bs]
 897
 898
 899 def intlist_to_bytes(xs):
 900     if not xs:
 901         return b''
 902     if isinstance(chr(0), bytes):  # Python 2
 903         return ''.join([chr(x) for x in xs])
 904     else:
 905         return bytes(xs)
 906
 907
 908 def get_cachedir(params={}):
 909     cache_root = os.environ.get('XDG_CACHE_HOME',
 910                                 os.path.expanduser('~/.cache'))
 911     return params.get('cachedir', os.path.join(cache_root, 'youtube-dl'))
 912
 913
 914 # Cross-platform file locking
 915 if sys.platform == 'win32':
 916     import ctypes.wintypes
 917     import msvcrt
 918
 919     class OVERLAPPED(ctypes.Structure):
 920         _fields_ = [
 921             ('Internal', ctypes.wintypes.LPVOID),
 922             ('InternalHigh', ctypes.wintypes.LPVOID),
 923             ('Offset', ctypes.wintypes.DWORD),
 924             ('OffsetHigh', ctypes.wintypes.DWORD),
 925             ('hEvent', ctypes.wintypes.HANDLE),
 926         ]
 927
 928     kernel32 = ctypes.windll.kernel32
 929     LockFileEx = kernel32.LockFileEx
 930     LockFileEx.argtypes = [
 931         ctypes.wintypes.HANDLE,     # hFile
 932         ctypes.wintypes.DWORD,      # dwFlags
 933         ctypes.wintypes.DWORD,      # dwReserved
 934         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
 935         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
 936         ctypes.POINTER(OVERLAPPED)  # Overlapped
 937     ]
 938     LockFileEx.restype = ctypes.wintypes.BOOL
 939     UnlockFileEx = kernel32.UnlockFileEx
 940     UnlockFileEx.argtypes = [
 941         ctypes.wintypes.HANDLE,     # hFile
 942         ctypes.wintypes.DWORD,      # dwReserved
 943         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
 944         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
 945         ctypes.POINTER(OVERLAPPED)  # Overlapped
 946     ]
 947     UnlockFileEx.restype = ctypes.wintypes.BOOL
 948     whole_low = 0xffffffff
 949     whole_high = 0x7fffffff
 950
 951     def _lock_file(f, exclusive):
 952         overlapped = OVERLAPPED()
 953         overlapped.Offset = 0
 954         overlapped.OffsetHigh = 0
 955         overlapped.hEvent = 0
 956         f._lock_file_overlapped_p = ctypes.pointer(overlapped)
 957         handle = msvcrt.get_osfhandle(f.fileno())
 958         if not LockFileEx(handle, 0x2 if exclusive else 0x0, 0,
 959                           whole_low, whole_high, f._lock_file_overlapped_p):
 960             raise OSError('Locking file failed: %r' % ctypes.FormatError())
 961
 962     def _unlock_file(f):
 963         assert f._lock_file_overlapped_p
 964         handle = msvcrt.get_osfhandle(f.fileno())
 965         if not UnlockFileEx(handle, 0,
 966                             whole_low, whole_high, f._lock_file_overlapped_p):
 967             raise OSError('Unlocking file failed: %r' % ctypes.FormatError())
 968
 969 else:
 970     import fcntl
 971
 972     def _lock_file(f, exclusive):
 973         fcntl.lockf(f, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
 974
 975     def _unlock_file(f):
 976         fcntl.lockf(f, fcntl.LOCK_UN)
 977
 978
 979 class locked_file(object):
 980     def __init__(self, filename, mode, encoding=None):
 981         assert mode in ['r', 'a', 'w']
 982         self.f = io.open(filename, mode, encoding=encoding)
 983         self.mode = mode
 984
 985     def __enter__(self):
 986         exclusive = self.mode != 'r'
 987         try:
 988             _lock_file(self.f, exclusive)
 989         except IOError:
 990             self.f.close()
 991             raise
 992         return self
 993
 994     def __exit__(self, etype, value, traceback):
 995         try:
 996             _unlock_file(self.f)
 997         finally:
 998             self.f.close()
 999
1000     def __iter__(self):
1001         return iter(self.f)
1002
1003     def write(self, *args):
1004         return self.f.write(*args)
1005
1006     def read(self, *args):
1007         return self.f.read(*args)
1008
1009
1010 def shell_quote(args):
1011     quoted_args = []
1012     encoding = sys.getfilesystemencoding()
1013     if encoding is None:
1014         encoding = 'utf-8'
1015     for a in args:
1016         if isinstance(a, bytes):
1017             # We may get a filename encoded with 'encodeFilename'
1018             a = a.decode(encoding)
1019         quoted_args.append(pipes.quote(a))
1020     return u' '.join(quoted_args)
1021
1022
1023 def takewhile_inclusive(pred, seq):
1024     """ Like itertools.takewhile, but include the latest evaluated element
1025         (the first element so that Not pred(e)) """
1026     for e in seq:
1027         yield e
1028         if not pred(e):
1029             return
1030
1031
1032 def smuggle_url(url, data):
1033     """ Pass additional data in a URL for internal use. """
1034
1035     sdata = compat_urllib_parse.urlencode(
1036         {u'__youtubedl_smuggle': json.dumps(data)})
1037     return url + u'#' + sdata
1038
1039
1040 def unsmuggle_url(smug_url, default=None):
1041     if not '#__youtubedl_smuggle' in smug_url:
1042         return smug_url, default
1043     url, _, sdata = smug_url.rpartition(u'#')
1044     jsond = compat_parse_qs(sdata)[u'__youtubedl_smuggle'][0]
1045     data = json.loads(jsond)
1046     return url, data
1047
1048
1049 def format_bytes(bytes):
1050     if bytes is None:
1051         return u'N/A'
1052     if type(bytes) is str:
1053         bytes = float(bytes)
1054     if bytes == 0.0:
1055         exponent = 0
1056     else:
1057         exponent = int(math.log(bytes, 1024.0))
1058     suffix = [u'B', u'KiB', u'MiB', u'GiB', u'TiB', u'PiB', u'EiB', u'ZiB', u'YiB'][exponent]
1059     converted = float(bytes) / float(1024 ** exponent)
1060     return u'%.2f%s' % (converted, suffix)
1061
1062
1063 def str_to_int(int_str):
1064     int_str = re.sub(r'[,\.]', u'', int_str)
1065     return int(int_str)
1066
1067
1068 def get_term_width():
1069     columns = os.environ.get('COLUMNS', None)
1070     if columns:
1071         return int(columns)
1072
1073     try:
1074         sp = subprocess.Popen(
1075             ['stty', 'size'],
1076             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
1077         out, err = sp.communicate()
1078         return int(out.split()[1])
1079     except:
1080         pass
1081     return None
1082
1083
1084 def month_by_name(name):
1085     """ Return the number of a month by (locale-independently) English name """
1086
1087     ENGLISH_NAMES = [
1088         u'January', u'February', u'March', u'April', u'May', u'June',
1089         u'July', u'August', u'September', u'October', u'November', u'December']
1090     try:
1091         return ENGLISH_NAMES.index(name) + 1
1092     except ValueError:
1093         return None
1094
1095
1096 def fix_xml_ampersands(xml_str):
1097     """Replace all the '&' by '&amp;' in XML"""
1098     return re.sub(
1099         r'&(?!amp;|lt;|gt;|apos;|quot;|#x[0-9a-fA-F]{,4};|#[0-9]{,4};)',
1100         u'&amp;',
1101         xml_str)
1102
1103
1104 def setproctitle(title):
1105     assert isinstance(title, compat_str)
1106     try:
1107         libc = ctypes.cdll.LoadLibrary("libc.so.6")
1108     except OSError:
1109         return
1110     title = title
1111     buf = ctypes.create_string_buffer(len(title) + 1)
1112     buf.value = title.encode('utf-8')
1113     try:
1114         libc.prctl(15, ctypes.byref(buf), 0, 0, 0)
1115     except AttributeError:
1116         return  # Strange libc, just skip this
1117
1118
1119 def remove_start(s, start):
1120     if s.startswith(start):
1121         return s[len(start):]
1122     return s
1123
1124
1125 def url_basename(url):
1126     path = compat_urlparse.urlparse(url).path
1127     return path.strip(u'/').split(u'/')[-1]
1128
1129
1130 class HEADRequest(compat_urllib_request.Request):
1131     def get_method(self):
1132         return "HEAD"
1133
1134
1135 def int_or_none(v, scale=1):
1136     return v if v is None else (int(v) // scale)
1137
1138
1139 def parse_duration(s):
1140     if s is None:
1141         return None
1142
1143     m = re.match(
1144         r'(?:(?:(?P<hours>[0-9]+):)?(?P<mins>[0-9]+):)?(?P<secs>[0-9]+)$', s)
1145     if not m:
1146         return None
1147     res = int(m.group('secs'))
1148     if m.group('mins'):
1149         res += int(m.group('mins')) * 60
1150         if m.group('hours'):
1151             res += int(m.group('hours')) * 60 * 60
1152     return res
1153
1154
1155 def prepend_extension(filename, ext):
1156     name, real_ext = os.path.splitext(filename)
1157     return u'{0}.{1}{2}'.format(name, ext, real_ext)
1158
1159
1160 def check_executable(exe, args=[]):
1161     """ Checks if the given binary is installed somewhere in PATH, and returns its name.
1162     args can be a list of arguments for a short output (like -version) """
1163     try:
1164         subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
1165     except OSError:
1166         return False
1167     return exe
1168
1169
1170 class PagedList(object):
1171     def __init__(self, pagefunc, pagesize):
1172         self._pagefunc = pagefunc
1173         self._pagesize = pagesize
1174
1175     def __len__(self):
1176         # This is only useful for tests
1177         return len(self.getslice())
1178
1179     def getslice(self, start=0, end=None):
1180         res = []
1181         for pagenum in itertools.count(start // self._pagesize):
1182             firstid = pagenum * self._pagesize
1183             nextfirstid = pagenum * self._pagesize + self._pagesize
1184             if start >= nextfirstid:
1185                 continue
1186
1187             page_results = list(self._pagefunc(pagenum))
1188
1189             startv = (
1190                 start % self._pagesize
1191                 if firstid <= start < nextfirstid
1192                 else 0)
1193
1194             endv = (
1195                 ((end - 1) % self._pagesize) + 1
1196                 if (end is not None and firstid <= end <= nextfirstid)
1197                 else None)
1198
1199             if startv != 0 or endv is not None:
1200                 page_results = page_results[startv:endv]
1201             res.extend(page_results)
1202
1203             # A little optimization - if current page is not "full", ie. does
1204             # not contain page_size videos then we can assume that this page
1205             # is the last one - there are no more ids on further pages -
1206             # i.e. no need to query again.
1207             if len(page_results) + startv < self._pagesize:
1208                 break
1209
1210             # If we got the whole page, but the next page is not interesting,
1211             # break out early as well
1212             if end == nextfirstid:
1213                 break
1214         return res