_ 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 base64
   7 import binascii
   8 import calendar
   9 import codecs
  10 import contextlib
  11 import ctypes
  12 import datetime
  13 import email.utils
  14 import errno
  15 import functools
  16 import gzip
  17 import itertools
  18 import io
  19 import json
  20 import locale
  21 import math
  22 import operator
  23 import os
  24 import pipes
  25 import platform
  26 import re
  27 import ssl
  28 import socket
  29 import struct
  30 import subprocess
  31 import sys
  32 import tempfile
  33 import traceback
  34 import xml.etree.ElementTree
  35 import zlib
  36
  37 from .compat import (
  38     compat_HTMLParser,
  39     compat_basestring,
  40     compat_chr,
  41     compat_etree_fromstring,
  42     compat_html_entities,
  43     compat_http_client,
  44     compat_kwargs,
  45     compat_parse_qs,
  46     compat_socket_create_connection,
  47     compat_str,
  48     compat_urllib_error,
  49     compat_urllib_parse,
  50     compat_urllib_parse_urlparse,
  51     compat_urllib_request,
  52     compat_urlparse,
  53     shlex_quote,
  54 )
  55
  56
  57 # This is not clearly defined otherwise
  58 compiled_regex_type = type(re.compile(''))
  59
  60 std_headers = {
  61     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20150101 Firefox/44.0 (Chrome)',
  62     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
  63     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  64     'Accept-Encoding': 'gzip, deflate',
  65     'Accept-Language': 'en-us,en;q=0.5',
  66 }
  67
  68
  69 NO_DEFAULT = object()
  70
  71 ENGLISH_MONTH_NAMES = [
  72     'January', 'February', 'March', 'April', 'May', 'June',
  73     'July', 'August', 'September', 'October', 'November', 'December']
  74
  75 KNOWN_EXTENSIONS = (
  76     'mp4', 'm4a', 'm4p', 'm4b', 'm4r', 'm4v', 'aac',
  77     'flv', 'f4v', 'f4a', 'f4b',
  78     'webm', 'ogg', 'ogv', 'oga', 'ogx', 'spx', 'opus',
  79     'mkv', 'mka', 'mk3d',
  80     'avi', 'divx',
  81     'mov',
  82     'asf', 'wmv', 'wma',
  83     '3gp', '3g2',
  84     'mp3',
  85     'flac',
  86     'ape',
  87     'wav',
  88     'f4f', 'f4m', 'm3u8', 'smil')
  89
  90
  91 def preferredencoding():
  92     """Get preferred encoding.
  93
  94     Returns the best encoding scheme for the system, based on
  95     locale.getpreferredencoding() and some further tweaks.
  96     """
  97     try:
  98         pref = locale.getpreferredencoding()
  99         'TEST'.encode(pref)
 100     except Exception:
 101         pref = 'UTF-8'
 102
 103     return pref
 104
 105
 106 def write_json_file(obj, fn):
 107     """ Encode obj as JSON and write it to fn, atomically if possible """
 108
 109     fn = encodeFilename(fn)
 110     if sys.version_info < (3, 0) and sys.platform != 'win32':
 111         encoding = get_filesystem_encoding()
 112         # os.path.basename returns a bytes object, but NamedTemporaryFile
 113         # will fail if the filename contains non ascii characters unless we
 114         # use a unicode object
 115         path_basename = lambda f: os.path.basename(fn).decode(encoding)
 116         # the same for os.path.dirname
 117         path_dirname = lambda f: os.path.dirname(fn).decode(encoding)
 118     else:
 119         path_basename = os.path.basename
 120         path_dirname = os.path.dirname
 121
 122     args = {
 123         'suffix': '.tmp',
 124         'prefix': path_basename(fn) + '.',
 125         'dir': path_dirname(fn),
 126         'delete': False,
 127     }
 128
 129     # In Python 2.x, json.dump expects a bytestream.
 130     # In Python 3.x, it writes to a character stream
 131     if sys.version_info < (3, 0):
 132         args['mode'] = 'wb'
 133     else:
 134         args.update({
 135             'mode': 'w',
 136             'encoding': 'utf-8',
 137         })
 138
 139     tf = tempfile.NamedTemporaryFile(**compat_kwargs(args))
 140
 141     try:
 142         with tf:
 143             json.dump(obj, tf)
 144         if sys.platform == 'win32':
 145             # Need to remove existing file on Windows, else os.rename raises
 146             # WindowsError or FileExistsError.
 147             try:
 148                 os.unlink(fn)
 149             except OSError:
 150                 pass
 151         os.rename(tf.name, fn)
 152     except Exception:
 153         try:
 154             os.remove(tf.name)
 155         except OSError:
 156             pass
 157         raise
 158
 159
 160 if sys.version_info >= (2, 7):
 161     def find_xpath_attr(node, xpath, key, val=None):
 162         """ Find the xpath xpath[@key=val] """
 163         assert re.match(r'^[a-zA-Z_-]+$', key)
 164         expr = xpath + ('[@%s]' % key if val is None else "[@%s='%s']" % (key, val))
 165         return node.find(expr)
 166 else:
 167     def find_xpath_attr(node, xpath, key, val=None):
 168         # Here comes the crazy part: In 2.6, if the xpath is a unicode,
 169         # .//node does not match if a node is a direct child of . !
 170         if isinstance(xpath, compat_str):
 171             xpath = xpath.encode('ascii')
 172
 173         for f in node.findall(xpath):
 174             if key not in f.attrib:
 175                 continue
 176             if val is None or f.attrib.get(key) == val:
 177                 return f
 178         return None
 179
 180 # On python2.6 the xml.etree.ElementTree.Element methods don't support
 181 # the namespace parameter
 182
 183
 184 def xpath_with_ns(path, ns_map):
 185     components = [c.split(':') for c in path.split('/')]
 186     replaced = []
 187     for c in components:
 188         if len(c) == 1:
 189             replaced.append(c[0])
 190         else:
 191             ns, tag = c
 192             replaced.append('{%s}%s' % (ns_map[ns], tag))
 193     return '/'.join(replaced)
 194
 195
 196 def xpath_element(node, xpath, name=None, fatal=False, default=NO_DEFAULT):
 197     def _find_xpath(xpath):
 198         if sys.version_info < (2, 7):  # Crazy 2.6
 199             xpath = xpath.encode('ascii')
 200         return node.find(xpath)
 201
 202     if isinstance(xpath, (str, compat_str)):
 203         n = _find_xpath(xpath)
 204     else:
 205         for xp in xpath:
 206             n = _find_xpath(xp)
 207             if n is not None:
 208                 break
 209
 210     if n is None:
 211         if default is not NO_DEFAULT:
 212             return default
 213         elif fatal:
 214             name = xpath if name is None else name
 215             raise ExtractorError('Could not find XML element %s' % name)
 216         else:
 217             return None
 218     return n
 219
 220
 221 def xpath_text(node, xpath, name=None, fatal=False, default=NO_DEFAULT):
 222     n = xpath_element(node, xpath, name, fatal=fatal, default=default)
 223     if n is None or n == default:
 224         return n
 225     if n.text is None:
 226         if default is not NO_DEFAULT:
 227             return default
 228         elif fatal:
 229             name = xpath if name is None else name
 230             raise ExtractorError('Could not find XML element\'s text %s' % name)
 231         else:
 232             return None
 233     return n.text
 234
 235
 236 def xpath_attr(node, xpath, key, name=None, fatal=False, default=NO_DEFAULT):
 237     n = find_xpath_attr(node, xpath, key)
 238     if n is None:
 239         if default is not NO_DEFAULT:
 240             return default
 241         elif fatal:
 242             name = '%s[@%s]' % (xpath, key) if name is None else name
 243             raise ExtractorError('Could not find XML attribute %s' % name)
 244         else:
 245             return None
 246     return n.attrib[key]
 247
 248
 249 def get_element_by_id(id, html):
 250     """Return the content of the tag with the specified ID in the passed HTML document"""
 251     return get_element_by_attribute('id', id, html)
 252
 253
 254 def get_element_by_attribute(attribute, value, html):
 255     """Return the content of the tag with the specified attribute in the passed HTML document"""
 256
 257     m = re.search(r'''(?xs)
 258         <([a-zA-Z0-9:._-]+)
 259          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]+|="[^"]+"|='[^']+'))*?
 260          \s+%s=['"]?%s['"]?
 261          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]+|="[^"]+"|='[^']+'))*?
 262         \s*>
 263         (?P<content>.*?)
 264         </\1>
 265     ''' % (re.escape(attribute), re.escape(value)), html)
 266
 267     if not m:
 268         return None
 269     res = m.group('content')
 270
 271     if res.startswith('"') or res.startswith("'"):
 272         res = res[1:-1]
 273
 274     return unescapeHTML(res)
 275
 276
 277 class HTMLAttributeParser(compat_HTMLParser):
 278     """Trivial HTML parser to gather the attributes for a single element"""
 279     def __init__(self):
 280         self.attrs = {}
 281         compat_HTMLParser.__init__(self)
 282
 283     def handle_starttag(self, tag, attrs):
 284         self.attrs = dict(attrs)
 285
 286
 287 def extract_attributes(html_element):
 288     """Given a string for an HTML element such as
 289     <el
 290          a="foo" B="bar" c="&98;az" d=boz
 291          empty= noval entity="&amp;"
 292          sq='"' dq="'"
 293     >
 294     Decode and return a dictionary of attributes.
 295     {
 296         'a': 'foo', 'b': 'bar', c: 'baz', d: 'boz',
 297         'empty': '', 'noval': None, 'entity': '&',
 298         'sq': '"', 'dq': '\''
 299     }.
 300     NB HTMLParser is stricter in Python 2.6 & 3.2 than in later versions,
 301     but the cases in the unit test will work for all of 2.6, 2.7, 3.2-3.5.
 302     """
 303     parser = HTMLAttributeParser()
 304     parser.feed(html_element)
 305     parser.close()
 306     return parser.attrs
 307
 308
 309 def clean_html(html):
 310     """Clean an HTML snippet into a readable string"""
 311
 312     if html is None:  # Convenience for sanitizing descriptions etc.
 313         return html
 314
 315     # Newline vs <br />
 316     html = html.replace('\n', ' ')
 317     html = re.sub(r'\s*<\s*br\s*/?\s*>\s*', '\n', html)
 318     html = re.sub(r'<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
 319     # Strip html tags
 320     html = re.sub('<.*?>', '', html)
 321     # Replace html entities
 322     html = unescapeHTML(html)
 323     return html.strip()
 324
 325
 326 def sanitize_open(filename, open_mode):
 327     """Try to open the given filename, and slightly tweak it if this fails.
 328
 329     Attempts to open the given filename. If this fails, it tries to change
 330     the filename slightly, step by step, until it's either able to open it
 331     or it fails and raises a final exception, like the standard open()
 332     function.
 333
 334     It returns the tuple (stream, definitive_file_name).
 335     """
 336     try:
 337         if filename == '-':
 338             if sys.platform == 'win32':
 339                 import msvcrt
 340                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 341             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
 342         stream = open(encodeFilename(filename), open_mode)
 343         return (stream, filename)
 344     except (IOError, OSError) as err:
 345         if err.errno in (errno.EACCES,):
 346             raise
 347
 348         # In case of error, try to remove win32 forbidden chars
 349         alt_filename = sanitize_path(filename)
 350         if alt_filename == filename:
 351             raise
 352         else:
 353             # An exception here should be caught in the caller
 354             stream = open(encodeFilename(alt_filename), open_mode)
 355             return (stream, alt_filename)
 356
 357
 358 def timeconvert(timestr):
 359     """Convert RFC 2822 defined time string into system timestamp"""
 360     timestamp = None
 361     timetuple = email.utils.parsedate_tz(timestr)
 362     if timetuple is not None:
 363         timestamp = email.utils.mktime_tz(timetuple)
 364     return timestamp
 365
 366
 367 def sanitize_filename(s, restricted=False, is_id=False):
 368     """Sanitizes a string so it could be used as part of a filename.
 369     If restricted is set, use a stricter subset of allowed characters.
 370     Set is_id if this is not an arbitrary string, but an ID that should be kept if possible
 371     """
 372     def replace_insane(char):
 373         if char == '?' or ord(char) < 32 or ord(char) == 127:
 374             return ''
 375         elif char == '"':
 376             return '' if restricted else '\''
 377         elif char == ':':
 378             return '_-' if restricted else ' -'
 379         elif char in '\\/|*<>':
 380             return '_'
 381         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
 382             return '_'
 383         if restricted and ord(char) > 127:
 384             return '_'
 385         return char
 386
 387     # Handle timestamps
 388     s = re.sub(r'[0-9]+(?::[0-9]+)+', lambda m: m.group(0).replace(':', '_'), s)
 389     result = ''.join(map(replace_insane, s))
 390     if not is_id:
 391         while '__' in result:
 392             result = result.replace('__', '_')
 393         result = result.strip('_')
 394         # Common case of "Foreign band name - English song title"
 395         if restricted and result.startswith('-_'):
 396             result = result[2:]
 397         if result.startswith('-'):
 398             result = '_' + result[len('-'):]
 399         result = result.lstrip('.')
 400         if not result:
 401             result = '_'
 402     return result
 403
 404
 405 def sanitize_path(s):
 406     """Sanitizes and normalizes path on Windows"""
 407     if sys.platform != 'win32':
 408         return s
 409     drive_or_unc, _ = os.path.splitdrive(s)
 410     if sys.version_info < (2, 7) and not drive_or_unc:
 411         drive_or_unc, _ = os.path.splitunc(s)
 412     norm_path = os.path.normpath(remove_start(s, drive_or_unc)).split(os.path.sep)
 413     if drive_or_unc:
 414         norm_path.pop(0)
 415     sanitized_path = [
 416         path_part if path_part in ['.', '..'] else re.sub('(?:[/<>:"\\|\\\\?\\*]|[\s.]$)', '#', path_part)
 417         for path_part in norm_path]
 418     if drive_or_unc:
 419         sanitized_path.insert(0, drive_or_unc + os.path.sep)
 420     return os.path.join(*sanitized_path)
 421
 422
 423 # Prepend protocol-less URLs with `http:` scheme in order to mitigate the number of
 424 # unwanted failures due to missing protocol
 425 def sanitized_Request(url, *args, **kwargs):
 426     return compat_urllib_request.Request(
 427         'http:%s' % url if url.startswith('//') else url, *args, **kwargs)
 428
 429
 430 def orderedSet(iterable):
 431     """ Remove all duplicates from the input iterable """
 432     res = []
 433     for el in iterable:
 434         if el not in res:
 435             res.append(el)
 436     return res
 437
 438
 439 def _htmlentity_transform(entity):
 440     """Transforms an HTML entity to a character."""
 441     # Known non-numeric HTML entity
 442     if entity in compat_html_entities.name2codepoint:
 443         return compat_chr(compat_html_entities.name2codepoint[entity])
 444
 445     mobj = re.match(r'#(x[0-9a-fA-F]+|[0-9]+)', entity)
 446     if mobj is not None:
 447         numstr = mobj.group(1)
 448         if numstr.startswith('x'):
 449             base = 16
 450             numstr = '0%s' % numstr
 451         else:
 452             base = 10
 453         # See https://github.com/rg3/youtube-dl/issues/7518
 454         try:
 455             return compat_chr(int(numstr, base))
 456         except ValueError:
 457             pass
 458
 459     # Unknown entity in name, return its literal representation
 460     return '&%s;' % entity
 461
 462
 463 def unescapeHTML(s):
 464     if s is None:
 465         return None
 466     assert type(s) == compat_str
 467
 468     return re.sub(
 469         r'&([^;]+);', lambda m: _htmlentity_transform(m.group(1)), s)
 470
 471
 472 def get_subprocess_encoding():
 473     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 474         # For subprocess calls, encode with locale encoding
 475         # Refer to http://stackoverflow.com/a/9951851/35070
 476         encoding = preferredencoding()
 477     else:
 478         encoding = sys.getfilesystemencoding()
 479     if encoding is None:
 480         encoding = 'utf-8'
 481     return encoding
 482
 483
 484 def encodeFilename(s, for_subprocess=False):
 485     """
 486     @param s The name of the file
 487     """
 488
 489     assert type(s) == compat_str
 490
 491     # Python 3 has a Unicode API
 492     if sys.version_info >= (3, 0):
 493         return s
 494
 495     # Pass '' directly to use Unicode APIs on Windows 2000 and up
 496     # (Detecting Windows NT 4 is tricky because 'major >= 4' would
 497     # match Windows 9x series as well. Besides, NT 4 is obsolete.)
 498     if not for_subprocess and sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 499         return s
 500
 501     # Jython assumes filenames are Unicode strings though reported as Python 2.x compatible
 502     if sys.platform.startswith('java'):
 503         return s
 504
 505     return s.encode(get_subprocess_encoding(), 'ignore')
 506
 507
 508 def decodeFilename(b, for_subprocess=False):
 509
 510     if sys.version_info >= (3, 0):
 511         return b
 512
 513     if not isinstance(b, bytes):
 514         return b
 515
 516     return b.decode(get_subprocess_encoding(), 'ignore')
 517
 518
 519 def encodeArgument(s):
 520     if not isinstance(s, compat_str):
 521         # Legacy code that uses byte strings
 522         # Uncomment the following line after fixing all post processors
 523         # assert False, 'Internal error: %r should be of type %r, is %r' % (s, compat_str, type(s))
 524         s = s.decode('ascii')
 525     return encodeFilename(s, True)
 526
 527
 528 def decodeArgument(b):
 529     return decodeFilename(b, True)
 530
 531
 532 def decodeOption(optval):
 533     if optval is None:
 534         return optval
 535     if isinstance(optval, bytes):
 536         optval = optval.decode(preferredencoding())
 537
 538     assert isinstance(optval, compat_str)
 539     return optval
 540
 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(params, **kwargs):
 552     opts_no_check_certificate = params.get('nocheckcertificate', False)
 553     if hasattr(ssl, 'create_default_context'):  # Python >= 3.4 or 2.7.9
 554         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
 555         if opts_no_check_certificate:
 556             context.check_hostname = False
 557             context.verify_mode = ssl.CERT_NONE
 558         try:
 559             return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 560         except TypeError:
 561             # Python 2.7.8
 562             # (create_default_context present but HTTPSHandler has no context=)
 563             pass
 564
 565     if sys.version_info < (3, 2):
 566         return YoutubeDLHTTPSHandler(params, **kwargs)
 567     else:  # Python < 3.4
 568         context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
 569         context.verify_mode = (ssl.CERT_NONE
 570                                if opts_no_check_certificate
 571                                else ssl.CERT_REQUIRED)
 572         context.set_default_verify_paths()
 573         return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 574
 575
 576 def bug_reports_message():
 577     if ytdl_is_updateable():
 578         update_cmd = 'type  youtube-dl -U  to update'
 579     else:
 580         update_cmd = 'see  https://yt-dl.org/update  on how to update'
 581     msg = '; please report this issue on https://yt-dl.org/bug .'
 582     msg += ' Make sure you are using the latest version; %s.' % update_cmd
 583     msg += ' Be sure to call youtube-dl with the --verbose flag and include its complete output.'
 584     return msg
 585
 586
 587 class ExtractorError(Exception):
 588     """Error during info extraction."""
 589
 590     def __init__(self, msg, tb=None, expected=False, cause=None, video_id=None):
 591         """ tb, if given, is the original traceback (so that it can be printed out).
 592         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
 593         """
 594
 595         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
 596             expected = True
 597         if video_id is not None:
 598             msg = video_id + ': ' + msg
 599         if cause:
 600             msg += ' (caused by %r)' % cause
 601         if not expected:
 602             msg += bug_reports_message()
 603         super(ExtractorError, self).__init__(msg)
 604
 605         self.traceback = tb
 606         self.exc_info = sys.exc_info()  # preserve original exception
 607         self.cause = cause
 608         self.video_id = video_id
 609
 610     def format_traceback(self):
 611         if self.traceback is None:
 612             return None
 613         return ''.join(traceback.format_tb(self.traceback))
 614
 615
 616 class UnsupportedError(ExtractorError):
 617     def __init__(self, url):
 618         super(UnsupportedError, self).__init__(
 619             'Unsupported URL: %s' % url, expected=True)
 620         self.url = url
 621
 622
 623 class RegexNotFoundError(ExtractorError):
 624     """Error when a regex didn't match"""
 625     pass
 626
 627
 628 class DownloadError(Exception):
 629     """Download Error exception.
 630
 631     This exception may be thrown by FileDownloader objects if they are not
 632     configured to continue on errors. They will contain the appropriate
 633     error message.
 634     """
 635
 636     def __init__(self, msg, exc_info=None):
 637         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
 638         super(DownloadError, self).__init__(msg)
 639         self.exc_info = exc_info
 640
 641
 642 class SameFileError(Exception):
 643     """Same File exception.
 644
 645     This exception will be thrown by FileDownloader objects if they detect
 646     multiple files would have to be downloaded to the same file on disk.
 647     """
 648     pass
 649
 650
 651 class PostProcessingError(Exception):
 652     """Post Processing exception.
 653
 654     This exception may be raised by PostProcessor's .run() method to
 655     indicate an error in the postprocessing task.
 656     """
 657
 658     def __init__(self, msg):
 659         self.msg = msg
 660
 661
 662 class MaxDownloadsReached(Exception):
 663     """ --max-downloads limit has been reached. """
 664     pass
 665
 666
 667 class UnavailableVideoError(Exception):
 668     """Unavailable Format exception.
 669
 670     This exception will be thrown when a video is requested
 671     in a format that is not available for that video.
 672     """
 673     pass
 674
 675
 676 class ContentTooShortError(Exception):
 677     """Content Too Short exception.
 678
 679     This exception may be raised by FileDownloader objects when a file they
 680     download is too small for what the server announced first, indicating
 681     the connection was probably interrupted.
 682     """
 683
 684     def __init__(self, downloaded, expected):
 685         # Both in bytes
 686         self.downloaded = downloaded
 687         self.expected = expected
 688
 689
 690 def _create_http_connection(ydl_handler, http_class, is_https, *args, **kwargs):
 691     # Working around python 2 bug (see http://bugs.python.org/issue17849) by limiting
 692     # expected HTTP responses to meet HTTP/1.0 or later (see also
 693     # https://github.com/rg3/youtube-dl/issues/6727)
 694     if sys.version_info < (3, 0):
 695         kwargs[b'strict'] = True
 696     hc = http_class(*args, **kwargs)
 697     source_address = ydl_handler._params.get('source_address')
 698     if source_address is not None:
 699         sa = (source_address, 0)
 700         if hasattr(hc, 'source_address'):  # Python 2.7+
 701             hc.source_address = sa
 702         else:  # Python 2.6
 703             def _hc_connect(self, *args, **kwargs):
 704                 sock = compat_socket_create_connection(
 705                     (self.host, self.port), self.timeout, sa)
 706                 if is_https:
 707                     self.sock = ssl.wrap_socket(
 708                         sock, self.key_file, self.cert_file,
 709                         ssl_version=ssl.PROTOCOL_TLSv1)
 710                 else:
 711                     self.sock = sock
 712             hc.connect = functools.partial(_hc_connect, hc)
 713
 714     return hc
 715
 716
 717 def handle_youtubedl_headers(headers):
 718     filtered_headers = headers
 719
 720     if 'Youtubedl-no-compression' in filtered_headers:
 721         filtered_headers = dict((k, v) for k, v in filtered_headers.items() if k.lower() != 'accept-encoding')
 722         del filtered_headers['Youtubedl-no-compression']
 723
 724     return filtered_headers
 725
 726
 727 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 728     """Handler for HTTP requests and responses.
 729
 730     This class, when installed with an OpenerDirector, automatically adds
 731     the standard headers to every HTTP request and handles gzipped and
 732     deflated responses from web servers. If compression is to be avoided in
 733     a particular request, the original request in the program code only has
 734     to include the HTTP header "Youtubedl-no-compression", which will be
 735     removed before making the real request.
 736
 737     Part of this code was copied from:
 738
 739     http://techknack.net/python-urllib2-handlers/
 740
 741     Andrew Rowls, the author of that code, agreed to release it to the
 742     public domain.
 743     """
 744
 745     def __init__(self, params, *args, **kwargs):
 746         compat_urllib_request.HTTPHandler.__init__(self, *args, **kwargs)
 747         self._params = params
 748
 749     def http_open(self, req):
 750         return self.do_open(functools.partial(
 751             _create_http_connection, self, compat_http_client.HTTPConnection, False),
 752             req)
 753
 754     @staticmethod
 755     def deflate(data):
 756         try:
 757             return zlib.decompress(data, -zlib.MAX_WBITS)
 758         except zlib.error:
 759             return zlib.decompress(data)
 760
 761     @staticmethod
 762     def addinfourl_wrapper(stream, headers, url, code):
 763         if hasattr(compat_urllib_request.addinfourl, 'getcode'):
 764             return compat_urllib_request.addinfourl(stream, headers, url, code)
 765         ret = compat_urllib_request.addinfourl(stream, headers, url)
 766         ret.code = code
 767         return ret
 768
 769     def http_request(self, req):
 770         # According to RFC 3986, URLs can not contain non-ASCII characters, however this is not
 771         # always respected by websites, some tend to give out URLs with non percent-encoded
 772         # non-ASCII characters (see telemb.py, ard.py [#3412])
 773         # urllib chokes on URLs with non-ASCII characters (see http://bugs.python.org/issue3991)
 774         # To work around aforementioned issue we will replace request's original URL with
 775         # percent-encoded one
 776         # Since redirects are also affected (e.g. http://www.southpark.de/alle-episoden/s18e09)
 777         # the code of this workaround has been moved here from YoutubeDL.urlopen()
 778         url = req.get_full_url()
 779         url_escaped = escape_url(url)
 780
 781         # Substitute URL if any change after escaping
 782         if url != url_escaped:
 783             req_type = HEADRequest if req.get_method() == 'HEAD' else compat_urllib_request.Request
 784             new_req = req_type(
 785                 url_escaped, data=req.data, headers=req.headers,
 786                 origin_req_host=req.origin_req_host, unverifiable=req.unverifiable)
 787             new_req.timeout = req.timeout
 788             req = new_req
 789
 790         for h, v in std_headers.items():
 791             # Capitalize is needed because of Python bug 2275: http://bugs.python.org/issue2275
 792             # The dict keys are capitalized because of this bug by urllib
 793             if h.capitalize() not in req.headers:
 794                 req.add_header(h, v)
 795
 796         req.headers = handle_youtubedl_headers(req.headers)
 797
 798         if sys.version_info < (2, 7) and '#' in req.get_full_url():
 799             # Python 2.6 is brain-dead when it comes to fragments
 800             req._Request__original = req._Request__original.partition('#')[0]
 801             req._Request__r_type = req._Request__r_type.partition('#')[0]
 802
 803         return req
 804
 805     def http_response(self, req, resp):
 806         old_resp = resp
 807         # gzip
 808         if resp.headers.get('Content-encoding', '') == 'gzip':
 809             content = resp.read()
 810             gz = gzip.GzipFile(fileobj=io.BytesIO(content), mode='rb')
 811             try:
 812                 uncompressed = io.BytesIO(gz.read())
 813             except IOError as original_ioerror:
 814                 # There may be junk add the end of the file
 815                 # See http://stackoverflow.com/q/4928560/35070 for details
 816                 for i in range(1, 1024):
 817                     try:
 818                         gz = gzip.GzipFile(fileobj=io.BytesIO(content[:-i]), mode='rb')
 819                         uncompressed = io.BytesIO(gz.read())
 820                     except IOError:
 821                         continue
 822                     break
 823                 else:
 824                     raise original_ioerror
 825             resp = self.addinfourl_wrapper(uncompressed, old_resp.headers, old_resp.url, old_resp.code)
 826             resp.msg = old_resp.msg
 827             del resp.headers['Content-encoding']
 828         # deflate
 829         if resp.headers.get('Content-encoding', '') == 'deflate':
 830             gz = io.BytesIO(self.deflate(resp.read()))
 831             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
 832             resp.msg = old_resp.msg
 833             del resp.headers['Content-encoding']
 834         # Percent-encode redirect URL of Location HTTP header to satisfy RFC 3986 (see
 835         # https://github.com/rg3/youtube-dl/issues/6457).
 836         if 300 <= resp.code < 400:
 837             location = resp.headers.get('Location')
 838             if location:
 839                 # As of RFC 2616 default charset is iso-8859-1 that is respected by python 3
 840                 if sys.version_info >= (3, 0):
 841                     location = location.encode('iso-8859-1').decode('utf-8')
 842                 location_escaped = escape_url(location)
 843                 if location != location_escaped:
 844                     del resp.headers['Location']
 845                     resp.headers['Location'] = location_escaped
 846         return resp
 847
 848     https_request = http_request
 849     https_response = http_response
 850
 851
 852 class YoutubeDLHTTPSHandler(compat_urllib_request.HTTPSHandler):
 853     def __init__(self, params, https_conn_class=None, *args, **kwargs):
 854         compat_urllib_request.HTTPSHandler.__init__(self, *args, **kwargs)
 855         self._https_conn_class = https_conn_class or compat_http_client.HTTPSConnection
 856         self._params = params
 857
 858     def https_open(self, req):
 859         kwargs = {}
 860         if hasattr(self, '_context'):  # python > 2.6
 861             kwargs['context'] = self._context
 862         if hasattr(self, '_check_hostname'):  # python 3.x
 863             kwargs['check_hostname'] = self._check_hostname
 864         return self.do_open(functools.partial(
 865             _create_http_connection, self, self._https_conn_class, True),
 866             req, **kwargs)
 867
 868
 869 class YoutubeDLCookieProcessor(compat_urllib_request.HTTPCookieProcessor):
 870     def __init__(self, cookiejar=None):
 871         compat_urllib_request.HTTPCookieProcessor.__init__(self, cookiejar)
 872
 873     def http_response(self, request, response):
 874         # Python 2 will choke on next HTTP request in row if there are non-ASCII
 875         # characters in Set-Cookie HTTP header of last response (see
 876         # https://github.com/rg3/youtube-dl/issues/6769).
 877         # In order to at least prevent crashing we will percent encode Set-Cookie
 878         # header before HTTPCookieProcessor starts processing it.
 879         # if sys.version_info < (3, 0) and response.headers:
 880         #     for set_cookie_header in ('Set-Cookie', 'Set-Cookie2'):
 881         #         set_cookie = response.headers.get(set_cookie_header)
 882         #         if set_cookie:
 883         #             set_cookie_escaped = compat_urllib_parse.quote(set_cookie, b"%/;:@&=+$,!~*'()?#[] ")
 884         #             if set_cookie != set_cookie_escaped:
 885         #                 del response.headers[set_cookie_header]
 886         #                 response.headers[set_cookie_header] = set_cookie_escaped
 887         return compat_urllib_request.HTTPCookieProcessor.http_response(self, request, response)
 888
 889     https_request = compat_urllib_request.HTTPCookieProcessor.http_request
 890     https_response = http_response
 891
 892
 893 def parse_iso8601(date_str, delimiter='T', timezone=None):
 894     """ Return a UNIX timestamp from the given date """
 895
 896     if date_str is None:
 897         return None
 898
 899     date_str = re.sub(r'\.[0-9]+', '', date_str)
 900
 901     if timezone is None:
 902         m = re.search(
 903             r'(?:Z$| ?(?P<sign>\+|-)(?P<hours>[0-9]{2}):?(?P<minutes>[0-9]{2})$)',
 904             date_str)
 905         if not m:
 906             timezone = datetime.timedelta()
 907         else:
 908             date_str = date_str[:-len(m.group(0))]
 909             if not m.group('sign'):
 910                 timezone = datetime.timedelta()
 911             else:
 912                 sign = 1 if m.group('sign') == '+' else -1
 913                 timezone = datetime.timedelta(
 914                     hours=sign * int(m.group('hours')),
 915                     minutes=sign * int(m.group('minutes')))
 916     try:
 917         date_format = '%Y-%m-%d{0}%H:%M:%S'.format(delimiter)
 918         dt = datetime.datetime.strptime(date_str, date_format) - timezone
 919         return calendar.timegm(dt.timetuple())
 920     except ValueError:
 921         pass
 922
 923
 924 def unified_strdate(date_str, day_first=True):
 925     """Return a string with the date in the format YYYYMMDD"""
 926
 927     if date_str is None:
 928         return None
 929     upload_date = None
 930     # Replace commas
 931     date_str = date_str.replace(',', ' ')
 932     # %z (UTC offset) is only supported in python>=3.2
 933     if not re.match(r'^[0-9]{1,2}-[0-9]{1,2}-[0-9]{4}$', date_str):
 934         date_str = re.sub(r' ?(\+|-)[0-9]{2}:?[0-9]{2}$', '', date_str)
 935     # Remove AM/PM + timezone
 936     date_str = re.sub(r'(?i)\s*(?:AM|PM)(?:\s+[A-Z]+)?', '', date_str)
 937
 938     format_expressions = [
 939         '%d %B %Y',
 940         '%d %b %Y',
 941         '%B %d %Y',
 942         '%b %d %Y',
 943         '%b %dst %Y %I:%M',
 944         '%b %dnd %Y %I:%M',
 945         '%b %dth %Y %I:%M',
 946         '%Y %m %d',
 947         '%Y-%m-%d',
 948         '%Y/%m/%d',
 949         '%Y/%m/%d %H:%M:%S',
 950         '%Y-%m-%d %H:%M:%S',
 951         '%Y-%m-%d %H:%M:%S.%f',
 952         '%d.%m.%Y %H:%M',
 953         '%d.%m.%Y %H.%M',
 954         '%Y-%m-%dT%H:%M:%SZ',
 955         '%Y-%m-%dT%H:%M:%S.%fZ',
 956         '%Y-%m-%dT%H:%M:%S.%f0Z',
 957         '%Y-%m-%dT%H:%M:%S',
 958         '%Y-%m-%dT%H:%M:%S.%f',
 959         '%Y-%m-%dT%H:%M',
 960     ]
 961     if day_first:
 962         format_expressions.extend([
 963             '%d-%m-%Y',
 964             '%d.%m.%Y',
 965             '%d/%m/%Y',
 966             '%d/%m/%y',
 967             '%d/%m/%Y %H:%M:%S',
 968         ])
 969     else:
 970         format_expressions.extend([
 971             '%m-%d-%Y',
 972             '%m.%d.%Y',
 973             '%m/%d/%Y',
 974             '%m/%d/%y',
 975             '%m/%d/%Y %H:%M:%S',
 976         ])
 977     for expression in format_expressions:
 978         try:
 979             upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
 980         except ValueError:
 981             pass
 982     if upload_date is None:
 983         timetuple = email.utils.parsedate_tz(date_str)
 984         if timetuple:
 985             upload_date = datetime.datetime(*timetuple[:6]).strftime('%Y%m%d')
 986     if upload_date is not None:
 987         return compat_str(upload_date)
 988
 989
 990 def determine_ext(url, default_ext='unknown_video'):
 991     if url is None:
 992         return default_ext
 993     guess = url.partition('?')[0].rpartition('.')[2]
 994     if re.match(r'^[A-Za-z0-9]+$', guess):
 995         return guess
 996     # Try extract ext from URLs like http://example.com/foo/bar.mp4/?download
 997     elif guess.rstrip('/') in KNOWN_EXTENSIONS:
 998         return guess.rstrip('/')
 999     else:
1000         return default_ext
1001
1002
1003 def subtitles_filename(filename, sub_lang, sub_format):
1004     return filename.rsplit('.', 1)[0] + '.' + sub_lang + '.' + sub_format
1005
1006
1007 def date_from_str(date_str):
1008     """
1009     Return a datetime object from a string in the format YYYYMMDD or
1010     (now|today)[+-][0-9](day|week|month|year)(s)?"""
1011     today = datetime.date.today()
1012     if date_str in ('now', 'today'):
1013         return today
1014     if date_str == 'yesterday':
1015         return today - datetime.timedelta(days=1)
1016     match = re.match('(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
1017     if match is not None:
1018         sign = match.group('sign')
1019         time = int(match.group('time'))
1020         if sign == '-':
1021             time = -time
1022         unit = match.group('unit')
1023         # A bad approximation?
1024         if unit == 'month':
1025             unit = 'day'
1026             time *= 30
1027         elif unit == 'year':
1028             unit = 'day'
1029             time *= 365
1030         unit += 's'
1031         delta = datetime.timedelta(**{unit: time})
1032         return today + delta
1033     return datetime.datetime.strptime(date_str, '%Y%m%d').date()
1034
1035
1036 def hyphenate_date(date_str):
1037     """
1038     Convert a date in 'YYYYMMDD' format to 'YYYY-MM-DD' format"""
1039     match = re.match(r'^(\d\d\d\d)(\d\d)(\d\d)$', date_str)
1040     if match is not None:
1041         return '-'.join(match.groups())
1042     else:
1043         return date_str
1044
1045
1046 class DateRange(object):
1047     """Represents a time interval between two dates"""
1048
1049     def __init__(self, start=None, end=None):
1050         """start and end must be strings in the format accepted by date"""
1051         if start is not None:
1052             self.start = date_from_str(start)
1053         else:
1054             self.start = datetime.datetime.min.date()
1055         if end is not None:
1056             self.end = date_from_str(end)
1057         else:
1058             self.end = datetime.datetime.max.date()
1059         if self.start > self.end:
1060             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
1061
1062     @classmethod
1063     def day(cls, day):
1064         """Returns a range that only contains the given day"""
1065         return cls(day, day)
1066
1067     def __contains__(self, date):
1068         """Check if the date is in the range"""
1069         if not isinstance(date, datetime.date):
1070             date = date_from_str(date)
1071         return self.start <= date <= self.end
1072
1073     def __str__(self):
1074         return '%s - %s' % (self.start.isoformat(), self.end.isoformat())
1075
1076
1077 def platform_name():
1078     """ Returns the platform name as a compat_str """
1079     res = platform.platform()
1080     if isinstance(res, bytes):
1081         res = res.decode(preferredencoding())
1082
1083     assert isinstance(res, compat_str)
1084     return res
1085
1086
1087 def _windows_write_string(s, out):
1088     """ Returns True if the string was written using special methods,
1089     False if it has yet to be written out."""
1090     # Adapted from http://stackoverflow.com/a/3259271/35070
1091
1092     import ctypes
1093     import ctypes.wintypes
1094
1095     WIN_OUTPUT_IDS = {
1096         1: -11,
1097         2: -12,
1098     }
1099
1100     try:
1101         fileno = out.fileno()
1102     except AttributeError:
1103         # If the output stream doesn't have a fileno, it's virtual
1104         return False
1105     except io.UnsupportedOperation:
1106         # Some strange Windows pseudo files?
1107         return False
1108     if fileno not in WIN_OUTPUT_IDS:
1109         return False
1110
1111     GetStdHandle = ctypes.WINFUNCTYPE(
1112         ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD)(
1113         (b'GetStdHandle', ctypes.windll.kernel32))
1114     h = GetStdHandle(WIN_OUTPUT_IDS[fileno])
1115
1116     WriteConsoleW = ctypes.WINFUNCTYPE(
1117         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE, ctypes.wintypes.LPWSTR,
1118         ctypes.wintypes.DWORD, ctypes.POINTER(ctypes.wintypes.DWORD),
1119         ctypes.wintypes.LPVOID)((b'WriteConsoleW', ctypes.windll.kernel32))
1120     written = ctypes.wintypes.DWORD(0)
1121
1122     GetFileType = ctypes.WINFUNCTYPE(ctypes.wintypes.DWORD, ctypes.wintypes.DWORD)((b'GetFileType', ctypes.windll.kernel32))
1123     FILE_TYPE_CHAR = 0x0002
1124     FILE_TYPE_REMOTE = 0x8000
1125     GetConsoleMode = ctypes.WINFUNCTYPE(
1126         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE,
1127         ctypes.POINTER(ctypes.wintypes.DWORD))(
1128         (b'GetConsoleMode', ctypes.windll.kernel32))
1129     INVALID_HANDLE_VALUE = ctypes.wintypes.DWORD(-1).value
1130
1131     def not_a_console(handle):
1132         if handle == INVALID_HANDLE_VALUE or handle is None:
1133             return True
1134         return ((GetFileType(handle) & ~FILE_TYPE_REMOTE) != FILE_TYPE_CHAR or
1135                 GetConsoleMode(handle, ctypes.byref(ctypes.wintypes.DWORD())) == 0)
1136
1137     if not_a_console(h):
1138         return False
1139
1140     def next_nonbmp_pos(s):
1141         try:
1142             return next(i for i, c in enumerate(s) if ord(c) > 0xffff)
1143         except StopIteration:
1144             return len(s)
1145
1146     while s:
1147         count = min(next_nonbmp_pos(s), 1024)
1148
1149         ret = WriteConsoleW(
1150             h, s, count if count else 2, ctypes.byref(written), None)
1151         if ret == 0:
1152             raise OSError('Failed to write string')
1153         if not count:  # We just wrote a non-BMP character
1154             assert written.value == 2
1155             s = s[1:]
1156         else:
1157             assert written.value > 0
1158             s = s[written.value:]
1159     return True
1160
1161
1162 def write_string(s, out=None, encoding=None):
1163     if out is None:
1164         out = sys.stderr
1165     assert type(s) == compat_str
1166
1167     if sys.platform == 'win32' and encoding is None and hasattr(out, 'fileno'):
1168         if _windows_write_string(s, out):
1169             return
1170
1171     if ('b' in getattr(out, 'mode', '') or
1172             sys.version_info[0] < 3):  # Python 2 lies about mode of sys.stderr
1173         byt = s.encode(encoding or preferredencoding(), 'ignore')
1174         out.write(byt)
1175     elif hasattr(out, 'buffer'):
1176         enc = encoding or getattr(out, 'encoding', None) or preferredencoding()
1177         byt = s.encode(enc, 'ignore')
1178         out.buffer.write(byt)
1179     else:
1180         out.write(s)
1181     out.flush()
1182
1183
1184 def bytes_to_intlist(bs):
1185     if not bs:
1186         return []
1187     if isinstance(bs[0], int):  # Python 3
1188         return list(bs)
1189     else:
1190         return [ord(c) for c in bs]
1191
1192
1193 def intlist_to_bytes(xs):
1194     if not xs:
1195         return b''
1196     return struct_pack('%dB' % len(xs), *xs)
1197
1198
1199 # Cross-platform file locking
1200 if sys.platform == 'win32':
1201     import ctypes.wintypes
1202     import msvcrt
1203
1204     class OVERLAPPED(ctypes.Structure):
1205         _fields_ = [
1206             ('Internal', ctypes.wintypes.LPVOID),
1207             ('InternalHigh', ctypes.wintypes.LPVOID),
1208             ('Offset', ctypes.wintypes.DWORD),
1209             ('OffsetHigh', ctypes.wintypes.DWORD),
1210             ('hEvent', ctypes.wintypes.HANDLE),
1211         ]
1212
1213     kernel32 = ctypes.windll.kernel32
1214     LockFileEx = kernel32.LockFileEx
1215     LockFileEx.argtypes = [
1216         ctypes.wintypes.HANDLE,     # hFile
1217         ctypes.wintypes.DWORD,      # dwFlags
1218         ctypes.wintypes.DWORD,      # dwReserved
1219         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1220         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1221         ctypes.POINTER(OVERLAPPED)  # Overlapped
1222     ]
1223     LockFileEx.restype = ctypes.wintypes.BOOL
1224     UnlockFileEx = kernel32.UnlockFileEx
1225     UnlockFileEx.argtypes = [
1226         ctypes.wintypes.HANDLE,     # hFile
1227         ctypes.wintypes.DWORD,      # dwReserved
1228         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1229         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1230         ctypes.POINTER(OVERLAPPED)  # Overlapped
1231     ]
1232     UnlockFileEx.restype = ctypes.wintypes.BOOL
1233     whole_low = 0xffffffff
1234     whole_high = 0x7fffffff
1235
1236     def _lock_file(f, exclusive):
1237         overlapped = OVERLAPPED()
1238         overlapped.Offset = 0
1239         overlapped.OffsetHigh = 0
1240         overlapped.hEvent = 0
1241         f._lock_file_overlapped_p = ctypes.pointer(overlapped)
1242         handle = msvcrt.get_osfhandle(f.fileno())
1243         if not LockFileEx(handle, 0x2 if exclusive else 0x0, 0,
1244                           whole_low, whole_high, f._lock_file_overlapped_p):
1245             raise OSError('Locking file failed: %r' % ctypes.FormatError())
1246
1247     def _unlock_file(f):
1248         assert f._lock_file_overlapped_p
1249         handle = msvcrt.get_osfhandle(f.fileno())
1250         if not UnlockFileEx(handle, 0,
1251                             whole_low, whole_high, f._lock_file_overlapped_p):
1252             raise OSError('Unlocking file failed: %r' % ctypes.FormatError())
1253
1254 else:
1255     # Some platforms, such as Jython, is missing fcntl
1256     try:
1257         import fcntl
1258
1259         def _lock_file(f, exclusive):
1260             fcntl.flock(f, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
1261
1262         def _unlock_file(f):
1263             fcntl.flock(f, fcntl.LOCK_UN)
1264     except ImportError:
1265         UNSUPPORTED_MSG = 'file locking is not supported on this platform'
1266
1267         def _lock_file(f, exclusive):
1268             raise IOError(UNSUPPORTED_MSG)
1269
1270         def _unlock_file(f):
1271             raise IOError(UNSUPPORTED_MSG)
1272
1273
1274 class locked_file(object):
1275     def __init__(self, filename, mode, encoding=None):
1276         assert mode in ['r', 'a', 'w']
1277         self.f = io.open(filename, mode, encoding=encoding)
1278         self.mode = mode
1279
1280     def __enter__(self):
1281         exclusive = self.mode != 'r'
1282         try:
1283             _lock_file(self.f, exclusive)
1284         except IOError:
1285             self.f.close()
1286             raise
1287         return self
1288
1289     def __exit__(self, etype, value, traceback):
1290         try:
1291             _unlock_file(self.f)
1292         finally:
1293             self.f.close()
1294
1295     def __iter__(self):
1296         return iter(self.f)
1297
1298     def write(self, *args):
1299         return self.f.write(*args)
1300
1301     def read(self, *args):
1302         return self.f.read(*args)
1303
1304
1305 def get_filesystem_encoding():
1306     encoding = sys.getfilesystemencoding()
1307     return encoding if encoding is not None else 'utf-8'
1308
1309
1310 def shell_quote(args):
1311     quoted_args = []
1312     encoding = get_filesystem_encoding()
1313     for a in args:
1314         if isinstance(a, bytes):
1315             # We may get a filename encoded with 'encodeFilename'
1316             a = a.decode(encoding)
1317         quoted_args.append(pipes.quote(a))
1318     return ' '.join(quoted_args)
1319
1320
1321 def smuggle_url(url, data):
1322     """ Pass additional data in a URL for internal use. """
1323
1324     sdata = compat_urllib_parse.urlencode(
1325         {'__youtubedl_smuggle': json.dumps(data)})
1326     return url + '#' + sdata
1327
1328
1329 def unsmuggle_url(smug_url, default=None):
1330     if '#__youtubedl_smuggle' not in smug_url:
1331         return smug_url, default
1332     url, _, sdata = smug_url.rpartition('#')
1333     jsond = compat_parse_qs(sdata)['__youtubedl_smuggle'][0]
1334     data = json.loads(jsond)
1335     return url, data
1336
1337
1338 def format_bytes(bytes):
1339     if bytes is None:
1340         return 'N/A'
1341     if type(bytes) is str:
1342         bytes = float(bytes)
1343     if bytes == 0.0:
1344         exponent = 0
1345     else:
1346         exponent = int(math.log(bytes, 1024.0))
1347     suffix = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'][exponent]
1348     converted = float(bytes) / float(1024 ** exponent)
1349     return '%.2f%s' % (converted, suffix)
1350
1351
1352 def lookup_unit_table(unit_table, s):
1353     units_re = '|'.join(re.escape(u) for u in unit_table)
1354     m = re.match(
1355         r'(?P<num>[0-9]+(?:[,.][0-9]*)?)\s*(?P<unit>%s)' % units_re, s)
1356     if not m:
1357         return None
1358     num_str = m.group('num').replace(',', '.')
1359     mult = unit_table[m.group('unit')]
1360     return int(float(num_str) * mult)
1361
1362
1363 def parse_filesize(s):
1364     if s is None:
1365         return None
1366
1367     # The lower-case forms are of course incorrect and unofficial,
1368     # but we support those too
1369     _UNIT_TABLE = {
1370         'B': 1,
1371         'b': 1,
1372         'KiB': 1024,
1373         'KB': 1000,
1374         'kB': 1024,
1375         'Kb': 1000,
1376         'MiB': 1024 ** 2,
1377         'MB': 1000 ** 2,
1378         'mB': 1024 ** 2,
1379         'Mb': 1000 ** 2,
1380         'GiB': 1024 ** 3,
1381         'GB': 1000 ** 3,
1382         'gB': 1024 ** 3,
1383         'Gb': 1000 ** 3,
1384         'TiB': 1024 ** 4,
1385         'TB': 1000 ** 4,
1386         'tB': 1024 ** 4,
1387         'Tb': 1000 ** 4,
1388         'PiB': 1024 ** 5,
1389         'PB': 1000 ** 5,
1390         'pB': 1024 ** 5,
1391         'Pb': 1000 ** 5,
1392         'EiB': 1024 ** 6,
1393         'EB': 1000 ** 6,
1394         'eB': 1024 ** 6,
1395         'Eb': 1000 ** 6,
1396         'ZiB': 1024 ** 7,
1397         'ZB': 1000 ** 7,
1398         'zB': 1024 ** 7,
1399         'Zb': 1000 ** 7,
1400         'YiB': 1024 ** 8,
1401         'YB': 1000 ** 8,
1402         'yB': 1024 ** 8,
1403         'Yb': 1000 ** 8,
1404     }
1405
1406     return lookup_unit_table(_UNIT_TABLE, s)
1407
1408
1409 def parse_count(s):
1410     if s is None:
1411         return None
1412
1413     s = s.strip()
1414
1415     if re.match(r'^[\d,.]+$', s):
1416         return str_to_int(s)
1417
1418     _UNIT_TABLE = {
1419         'k': 1000,
1420         'K': 1000,
1421         'm': 1000 ** 2,
1422         'M': 1000 ** 2,
1423         'kk': 1000 ** 2,
1424         'KK': 1000 ** 2,
1425     }
1426
1427     return lookup_unit_table(_UNIT_TABLE, s)
1428
1429
1430 def month_by_name(name):
1431     """ Return the number of a month by (locale-independently) English name """
1432
1433     try:
1434         return ENGLISH_MONTH_NAMES.index(name) + 1
1435     except ValueError:
1436         return None
1437
1438
1439 def month_by_abbreviation(abbrev):
1440     """ Return the number of a month by (locale-independently) English
1441         abbreviations """
1442
1443     try:
1444         return [s[:3] for s in ENGLISH_MONTH_NAMES].index(abbrev) + 1
1445     except ValueError:
1446         return None
1447
1448
1449 def fix_xml_ampersands(xml_str):
1450     """Replace all the '&' by '&amp;' in XML"""
1451     return re.sub(
1452         r'&(?!amp;|lt;|gt;|apos;|quot;|#x[0-9a-fA-F]{,4};|#[0-9]{,4};)',
1453         '&amp;',
1454         xml_str)
1455
1456
1457 def setproctitle(title):
1458     assert isinstance(title, compat_str)
1459
1460     # ctypes in Jython is not complete
1461     # http://bugs.jython.org/issue2148
1462     if sys.platform.startswith('java'):
1463         return
1464
1465     try:
1466         libc = ctypes.cdll.LoadLibrary('libc.so.6')
1467     except OSError:
1468         return
1469     title_bytes = title.encode('utf-8')
1470     buf = ctypes.create_string_buffer(len(title_bytes))
1471     buf.value = title_bytes
1472     try:
1473         libc.prctl(15, buf, 0, 0, 0)
1474     except AttributeError:
1475         return  # Strange libc, just skip this
1476
1477
1478 def remove_start(s, start):
1479     if s.startswith(start):
1480         return s[len(start):]
1481     return s
1482
1483
1484 def remove_end(s, end):
1485     if s.endswith(end):
1486         return s[:-len(end)]
1487     return s
1488
1489
1490 def remove_quotes(s):
1491     if s is None or len(s) < 2:
1492         return s
1493     for quote in ('"', "'", ):
1494         if s[0] == quote and s[-1] == quote:
1495             return s[1:-1]
1496     return s
1497
1498
1499 def url_basename(url):
1500     path = compat_urlparse.urlparse(url).path
1501     return path.strip('/').split('/')[-1]
1502
1503
1504 class HEADRequest(compat_urllib_request.Request):
1505     def get_method(self):
1506         return 'HEAD'
1507
1508
1509 def int_or_none(v, scale=1, default=None, get_attr=None, invscale=1):
1510     if get_attr:
1511         if v is not None:
1512             v = getattr(v, get_attr, None)
1513     if v == '':
1514         v = None
1515     if v is None:
1516         return default
1517     try:
1518         return int(v) * invscale // scale
1519     except ValueError:
1520         return default
1521
1522
1523 def str_or_none(v, default=None):
1524     return default if v is None else compat_str(v)
1525
1526
1527 def str_to_int(int_str):
1528     """ A more relaxed version of int_or_none """
1529     if int_str is None:
1530         return None
1531     int_str = re.sub(r'[,\.\+]', '', int_str)
1532     return int(int_str)
1533
1534
1535 def float_or_none(v, scale=1, invscale=1, default=None):
1536     if v is None:
1537         return default
1538     try:
1539         return float(v) * invscale / scale
1540     except ValueError:
1541         return default
1542
1543
1544 def parse_duration(s):
1545     if not isinstance(s, compat_basestring):
1546         return None
1547
1548     s = s.strip()
1549
1550     m = re.match(
1551         r'''(?ix)(?:P?T)?
1552         (?:
1553             (?P<only_mins>[0-9.]+)\s*(?:mins?\.?|minutes?)\s*|
1554             (?P<only_hours>[0-9.]+)\s*(?:hours?)|
1555
1556             \s*(?P<hours_reversed>[0-9]+)\s*(?:[:h]|hours?)\s*(?P<mins_reversed>[0-9]+)\s*(?:[:m]|mins?\.?|minutes?)\s*|
1557             (?:
1558                 (?:
1559                     (?:(?P<days>[0-9]+)\s*(?:[:d]|days?)\s*)?
1560                     (?P<hours>[0-9]+)\s*(?:[:h]|hours?)\s*
1561                 )?
1562                 (?P<mins>[0-9]+)\s*(?:[:m]|mins?|minutes?)\s*
1563             )?
1564             (?P<secs>[0-9]+)(?P<ms>\.[0-9]+)?\s*(?:s|secs?|seconds?)?
1565         )$''', s)
1566     if not m:
1567         return None
1568     res = 0
1569     if m.group('only_mins'):
1570         return float_or_none(m.group('only_mins'), invscale=60)
1571     if m.group('only_hours'):
1572         return float_or_none(m.group('only_hours'), invscale=60 * 60)
1573     if m.group('secs'):
1574         res += int(m.group('secs'))
1575     if m.group('mins_reversed'):
1576         res += int(m.group('mins_reversed')) * 60
1577     if m.group('mins'):
1578         res += int(m.group('mins')) * 60
1579     if m.group('hours'):
1580         res += int(m.group('hours')) * 60 * 60
1581     if m.group('hours_reversed'):
1582         res += int(m.group('hours_reversed')) * 60 * 60
1583     if m.group('days'):
1584         res += int(m.group('days')) * 24 * 60 * 60
1585     if m.group('ms'):
1586         res += float(m.group('ms'))
1587     return res
1588
1589
1590 def prepend_extension(filename, ext, expected_real_ext=None):
1591     name, real_ext = os.path.splitext(filename)
1592     return (
1593         '{0}.{1}{2}'.format(name, ext, real_ext)
1594         if not expected_real_ext or real_ext[1:] == expected_real_ext
1595         else '{0}.{1}'.format(filename, ext))
1596
1597
1598 def replace_extension(filename, ext, expected_real_ext=None):
1599     name, real_ext = os.path.splitext(filename)
1600     return '{0}.{1}'.format(
1601         name if not expected_real_ext or real_ext[1:] == expected_real_ext else filename,
1602         ext)
1603
1604
1605 def check_executable(exe, args=[]):
1606     """ Checks if the given binary is installed somewhere in PATH, and returns its name.
1607     args can be a list of arguments for a short output (like -version) """
1608     try:
1609         subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
1610     except OSError:
1611         return False
1612     return exe
1613
1614
1615 def get_exe_version(exe, args=['--version'],
1616                     version_re=None, unrecognized='present'):
1617     """ Returns the version of the specified executable,
1618     or False if the executable is not present """
1619     try:
1620         out, _ = subprocess.Popen(
1621             [encodeArgument(exe)] + args,
1622             stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate()
1623     except OSError:
1624         return False
1625     if isinstance(out, bytes):  # Python 2.x
1626         out = out.decode('ascii', 'ignore')
1627     return detect_exe_version(out, version_re, unrecognized)
1628
1629
1630 def detect_exe_version(output, version_re=None, unrecognized='present'):
1631     assert isinstance(output, compat_str)
1632     if version_re is None:
1633         version_re = r'version\s+([-0-9._a-zA-Z]+)'
1634     m = re.search(version_re, output)
1635     if m:
1636         return m.group(1)
1637     else:
1638         return unrecognized
1639
1640
1641 class PagedList(object):
1642     def __len__(self):
1643         # This is only useful for tests
1644         return len(self.getslice())
1645
1646
1647 class OnDemandPagedList(PagedList):
1648     def __init__(self, pagefunc, pagesize, use_cache=False):
1649         self._pagefunc = pagefunc
1650         self._pagesize = pagesize
1651         self._use_cache = use_cache
1652         if use_cache:
1653             self._cache = {}
1654
1655     def getslice(self, start=0, end=None):
1656         res = []
1657         for pagenum in itertools.count(start // self._pagesize):
1658             firstid = pagenum * self._pagesize
1659             nextfirstid = pagenum * self._pagesize + self._pagesize
1660             if start >= nextfirstid:
1661                 continue
1662
1663             page_results = None
1664             if self._use_cache:
1665                 page_results = self._cache.get(pagenum)
1666             if page_results is None:
1667                 page_results = list(self._pagefunc(pagenum))
1668             if self._use_cache:
1669                 self._cache[pagenum] = page_results
1670
1671             startv = (
1672                 start % self._pagesize
1673                 if firstid <= start < nextfirstid
1674                 else 0)
1675
1676             endv = (
1677                 ((end - 1) % self._pagesize) + 1
1678                 if (end is not None and firstid <= end <= nextfirstid)
1679                 else None)
1680
1681             if startv != 0 or endv is not None:
1682                 page_results = page_results[startv:endv]
1683             res.extend(page_results)
1684
1685             # A little optimization - if current page is not "full", ie. does
1686             # not contain page_size videos then we can assume that this page
1687             # is the last one - there are no more ids on further pages -
1688             # i.e. no need to query again.
1689             if len(page_results) + startv < self._pagesize:
1690                 break
1691
1692             # If we got the whole page, but the next page is not interesting,
1693             # break out early as well
1694             if end == nextfirstid:
1695                 break
1696         return res
1697
1698
1699 class InAdvancePagedList(PagedList):
1700     def __init__(self, pagefunc, pagecount, pagesize):
1701         self._pagefunc = pagefunc
1702         self._pagecount = pagecount
1703         self._pagesize = pagesize
1704
1705     def getslice(self, start=0, end=None):
1706         res = []
1707         start_page = start // self._pagesize
1708         end_page = (
1709             self._pagecount if end is None else (end // self._pagesize + 1))
1710         skip_elems = start - start_page * self._pagesize
1711         only_more = None if end is None else end - start
1712         for pagenum in range(start_page, end_page):
1713             page = list(self._pagefunc(pagenum))
1714             if skip_elems:
1715                 page = page[skip_elems:]
1716                 skip_elems = None
1717             if only_more is not None:
1718                 if len(page) < only_more:
1719                     only_more -= len(page)
1720                 else:
1721                     page = page[:only_more]
1722                     res.extend(page)
1723                     break
1724             res.extend(page)
1725         return res
1726
1727
1728 def uppercase_escape(s):
1729     unicode_escape = codecs.getdecoder('unicode_escape')
1730     return re.sub(
1731         r'\\U[0-9a-fA-F]{8}',
1732         lambda m: unicode_escape(m.group(0))[0],
1733         s)
1734
1735
1736 def lowercase_escape(s):
1737     unicode_escape = codecs.getdecoder('unicode_escape')
1738     return re.sub(
1739         r'\\u[0-9a-fA-F]{4}',
1740         lambda m: unicode_escape(m.group(0))[0],
1741         s)
1742
1743
1744 def escape_rfc3986(s):
1745     """Escape non-ASCII characters as suggested by RFC 3986"""
1746     if sys.version_info < (3, 0) and isinstance(s, compat_str):
1747         s = s.encode('utf-8')
1748     return compat_urllib_parse.quote(s, b"%/;:@&=+$,!~*'()?#[]")
1749
1750
1751 def escape_url(url):
1752     """Escape URL as suggested by RFC 3986"""
1753     url_parsed = compat_urllib_parse_urlparse(url)
1754     return url_parsed._replace(
1755         path=escape_rfc3986(url_parsed.path),
1756         params=escape_rfc3986(url_parsed.params),
1757         query=escape_rfc3986(url_parsed.query),
1758         fragment=escape_rfc3986(url_parsed.fragment)
1759     ).geturl()
1760
1761 try:
1762     struct.pack('!I', 0)
1763 except TypeError:
1764     # In Python 2.6 (and some 2.7 versions), struct requires a bytes argument
1765     def struct_pack(spec, *args):
1766         if isinstance(spec, compat_str):
1767             spec = spec.encode('ascii')
1768         return struct.pack(spec, *args)
1769
1770     def struct_unpack(spec, *args):
1771         if isinstance(spec, compat_str):
1772             spec = spec.encode('ascii')
1773         return struct.unpack(spec, *args)
1774 else:
1775     struct_pack = struct.pack
1776     struct_unpack = struct.unpack
1777
1778
1779 def read_batch_urls(batch_fd):
1780     def fixup(url):
1781         if not isinstance(url, compat_str):
1782             url = url.decode('utf-8', 'replace')
1783         BOM_UTF8 = '\xef\xbb\xbf'
1784         if url.startswith(BOM_UTF8):
1785             url = url[len(BOM_UTF8):]
1786         url = url.strip()
1787         if url.startswith(('#', ';', ']')):
1788             return False
1789         return url
1790
1791     with contextlib.closing(batch_fd) as fd:
1792         return [url for url in map(fixup, fd) if url]
1793
1794
1795 def urlencode_postdata(*args, **kargs):
1796     return compat_urllib_parse.urlencode(*args, **kargs).encode('ascii')
1797
1798
1799 def update_url_query(url, query):
1800     parsed_url = compat_urlparse.urlparse(url)
1801     qs = compat_parse_qs(parsed_url.query)
1802     qs.update(query)
1803     qs = encode_dict(qs)
1804     return compat_urlparse.urlunparse(parsed_url._replace(
1805         query=compat_urllib_parse.urlencode(qs, True)))
1806
1807
1808 def encode_dict(d, encoding='utf-8'):
1809     def encode(v):
1810         return v.encode(encoding) if isinstance(v, compat_basestring) else v
1811     return dict((encode(k), encode(v)) for k, v in d.items())
1812
1813
1814 def dict_get(d, key_or_keys, default=None, skip_false_values=True):
1815     if isinstance(key_or_keys, (list, tuple)):
1816         for key in key_or_keys:
1817             if key not in d or d[key] is None or skip_false_values and not d[key]:
1818                 continue
1819             return d[key]
1820         return default
1821     return d.get(key_or_keys, default)
1822
1823
1824 def encode_compat_str(string, encoding=preferredencoding(), errors='strict'):
1825     return string if isinstance(string, compat_str) else compat_str(string, encoding, errors)
1826
1827
1828 US_RATINGS = {
1829     'G': 0,
1830     'PG': 10,
1831     'PG-13': 13,
1832     'R': 16,
1833     'NC': 18,
1834 }
1835
1836
1837 def parse_age_limit(s):
1838     if s is None:
1839         return None
1840     m = re.match(r'^(?P<age>\d{1,2})\+?$', s)
1841     return int(m.group('age')) if m else US_RATINGS.get(s)
1842
1843
1844 def strip_jsonp(code):
1845     return re.sub(
1846         r'(?s)^[a-zA-Z0-9_.]+\s*\(\s*(.*)\);?\s*?(?://[^\n]*)*$', r'\1', code)
1847
1848
1849 def js_to_json(code):
1850     def fix_kv(m):
1851         v = m.group(0)
1852         if v in ('true', 'false', 'null'):
1853             return v
1854         if v.startswith('"'):
1855             v = re.sub(r"\\'", "'", v[1:-1])
1856         elif v.startswith("'"):
1857             v = v[1:-1]
1858             v = re.sub(r"\\\\|\\'|\"", lambda m: {
1859                 '\\\\': '\\\\',
1860                 "\\'": "'",
1861                 '"': '\\"',
1862             }[m.group(0)], v)
1863         return '"%s"' % v
1864
1865     res = re.sub(r'''(?x)
1866         "(?:[^"\\]*(?:\\\\|\\['"nu]))*[^"\\]*"|
1867         '(?:[^'\\]*(?:\\\\|\\['"nu]))*[^'\\]*'|
1868         [a-zA-Z_][.a-zA-Z_0-9]*
1869         ''', fix_kv, code)
1870     res = re.sub(r',(\s*[\]}])', lambda m: m.group(1), res)
1871     return res
1872
1873
1874 def qualities(quality_ids):
1875     """ Get a numeric quality value out of a list of possible values """
1876     def q(qid):
1877         try:
1878             return quality_ids.index(qid)
1879         except ValueError:
1880             return -1
1881     return q
1882
1883
1884 DEFAULT_OUTTMPL = '%(title)s-%(id)s.%(ext)s'
1885
1886
1887 def limit_length(s, length):
1888     """ Add ellipses to overly long strings """
1889     if s is None:
1890         return None
1891     ELLIPSES = '...'
1892     if len(s) > length:
1893         return s[:length - len(ELLIPSES)] + ELLIPSES
1894     return s
1895
1896
1897 def version_tuple(v):
1898     return tuple(int(e) for e in re.split(r'[-.]', v))
1899
1900
1901 def is_outdated_version(version, limit, assume_new=True):
1902     if not version:
1903         return not assume_new
1904     try:
1905         return version_tuple(version) < version_tuple(limit)
1906     except ValueError:
1907         return not assume_new
1908
1909
1910 def ytdl_is_updateable():
1911     """ Returns if youtube-dl can be updated with -U """
1912     from zipimport import zipimporter
1913
1914     return isinstance(globals().get('__loader__'), zipimporter) or hasattr(sys, 'frozen')
1915
1916
1917 def args_to_str(args):
1918     # Get a short string representation for a subprocess command
1919     return ' '.join(shlex_quote(a) for a in args)
1920
1921
1922 def error_to_compat_str(err):
1923     err_str = str(err)
1924     # On python 2 error byte string must be decoded with proper
1925     # encoding rather than ascii
1926     if sys.version_info[0] < 3:
1927         err_str = err_str.decode(preferredencoding())
1928     return err_str
1929
1930
1931 def mimetype2ext(mt):
1932     ext = {
1933         'audio/mp4': 'm4a',
1934     }.get(mt)
1935     if ext is not None:
1936         return ext
1937
1938     _, _, res = mt.rpartition('/')
1939
1940     return {
1941         '3gpp': '3gp',
1942         'smptett+xml': 'tt',
1943         'srt': 'srt',
1944         'ttaf+xml': 'dfxp',
1945         'ttml+xml': 'ttml',
1946         'vtt': 'vtt',
1947         'x-flv': 'flv',
1948         'x-mp4-fragmented': 'mp4',
1949         'x-ms-wmv': 'wmv',
1950     }.get(res, res)
1951
1952
1953 def urlhandle_detect_ext(url_handle):
1954     try:
1955         url_handle.headers
1956         getheader = lambda h: url_handle.headers[h]
1957     except AttributeError:  # Python < 3
1958         getheader = url_handle.info().getheader
1959
1960     cd = getheader('Content-Disposition')
1961     if cd:
1962         m = re.match(r'attachment;\s*filename="(?P<filename>[^"]+)"', cd)
1963         if m:
1964             e = determine_ext(m.group('filename'), default_ext=None)
1965             if e:
1966                 return e
1967
1968     return mimetype2ext(getheader('Content-Type'))
1969
1970
1971 def encode_data_uri(data, mime_type):
1972     return 'data:%s;base64,%s' % (mime_type, base64.b64encode(data).decode('ascii'))
1973
1974
1975 def age_restricted(content_limit, age_limit):
1976     """ Returns True iff the content should be blocked """
1977
1978     if age_limit is None:  # No limit set
1979         return False
1980     if content_limit is None:
1981         return False  # Content available for everyone
1982     return age_limit < content_limit
1983
1984
1985 def is_html(first_bytes):
1986     """ Detect whether a file contains HTML by examining its first bytes. """
1987
1988     BOMS = [
1989         (b'\xef\xbb\xbf', 'utf-8'),
1990         (b'\x00\x00\xfe\xff', 'utf-32-be'),
1991         (b'\xff\xfe\x00\x00', 'utf-32-le'),
1992         (b'\xff\xfe', 'utf-16-le'),
1993         (b'\xfe\xff', 'utf-16-be'),
1994     ]
1995     for bom, enc in BOMS:
1996         if first_bytes.startswith(bom):
1997             s = first_bytes[len(bom):].decode(enc, 'replace')
1998             break
1999     else:
2000         s = first_bytes.decode('utf-8', 'replace')
2001
2002     return re.match(r'^\s*<', s)
2003
2004
2005 def determine_protocol(info_dict):
2006     protocol = info_dict.get('protocol')
2007     if protocol is not None:
2008         return protocol
2009
2010     url = info_dict['url']
2011     if url.startswith('rtmp'):
2012         return 'rtmp'
2013     elif url.startswith('mms'):
2014         return 'mms'
2015     elif url.startswith('rtsp'):
2016         return 'rtsp'
2017
2018     ext = determine_ext(url)
2019     if ext == 'm3u8':
2020         return 'm3u8'
2021     elif ext == 'f4m':
2022         return 'f4m'
2023
2024     return compat_urllib_parse_urlparse(url).scheme
2025
2026
2027 def render_table(header_row, data):
2028     """ Render a list of rows, each as a list of values """
2029     table = [header_row] + data
2030     max_lens = [max(len(compat_str(v)) for v in col) for col in zip(*table)]
2031     format_str = ' '.join('%-' + compat_str(ml + 1) + 's' for ml in max_lens[:-1]) + '%s'
2032     return '\n'.join(format_str % tuple(row) for row in table)
2033
2034
2035 def _match_one(filter_part, dct):
2036     COMPARISON_OPERATORS = {
2037         '<': operator.lt,
2038         '<=': operator.le,
2039         '>': operator.gt,
2040         '>=': operator.ge,
2041         '=': operator.eq,
2042         '!=': operator.ne,
2043     }
2044     operator_rex = re.compile(r'''(?x)\s*
2045         (?P<key>[a-z_]+)
2046         \s*(?P<op>%s)(?P<none_inclusive>\s*\?)?\s*
2047         (?:
2048             (?P<intval>[0-9.]+(?:[kKmMgGtTpPeEzZyY]i?[Bb]?)?)|
2049             (?P<strval>(?![0-9.])[a-z0-9A-Z]*)
2050         )
2051         \s*$
2052         ''' % '|'.join(map(re.escape, COMPARISON_OPERATORS.keys())))
2053     m = operator_rex.search(filter_part)
2054     if m:
2055         op = COMPARISON_OPERATORS[m.group('op')]
2056         if m.group('strval') is not None:
2057             if m.group('op') not in ('=', '!='):
2058                 raise ValueError(
2059                     'Operator %s does not support string values!' % m.group('op'))
2060             comparison_value = m.group('strval')
2061         else:
2062             try:
2063                 comparison_value = int(m.group('intval'))
2064             except ValueError:
2065                 comparison_value = parse_filesize(m.group('intval'))
2066                 if comparison_value is None:
2067                     comparison_value = parse_filesize(m.group('intval') + 'B')
2068                 if comparison_value is None:
2069                     raise ValueError(
2070                         'Invalid integer value %r in filter part %r' % (
2071                             m.group('intval'), filter_part))
2072         actual_value = dct.get(m.group('key'))
2073         if actual_value is None:
2074             return m.group('none_inclusive')
2075         return op(actual_value, comparison_value)
2076
2077     UNARY_OPERATORS = {
2078         '': lambda v: v is not None,
2079         '!': lambda v: v is None,
2080     }
2081     operator_rex = re.compile(r'''(?x)\s*
2082         (?P<op>%s)\s*(?P<key>[a-z_]+)
2083         \s*$
2084         ''' % '|'.join(map(re.escape, UNARY_OPERATORS.keys())))
2085     m = operator_rex.search(filter_part)
2086     if m:
2087         op = UNARY_OPERATORS[m.group('op')]
2088         actual_value = dct.get(m.group('key'))
2089         return op(actual_value)
2090
2091     raise ValueError('Invalid filter part %r' % filter_part)
2092
2093
2094 def match_str(filter_str, dct):
2095     """ Filter a dictionary with a simple string syntax. Returns True (=passes filter) or false """
2096
2097     return all(
2098         _match_one(filter_part, dct) for filter_part in filter_str.split('&'))
2099
2100
2101 def match_filter_func(filter_str):
2102     def _match_func(info_dict):
2103         if match_str(filter_str, info_dict):
2104             return None
2105         else:
2106             video_title = info_dict.get('title', info_dict.get('id', 'video'))
2107             return '%s does not pass filter %s, skipping ..' % (video_title, filter_str)
2108     return _match_func
2109
2110
2111 def parse_dfxp_time_expr(time_expr):
2112     if not time_expr:
2113         return
2114
2115     mobj = re.match(r'^(?P<time_offset>\d+(?:\.\d+)?)s?$', time_expr)
2116     if mobj:
2117         return float(mobj.group('time_offset'))
2118
2119     mobj = re.match(r'^(\d+):(\d\d):(\d\d(?:(?:\.|:)\d+)?)$', time_expr)
2120     if mobj:
2121         return 3600 * int(mobj.group(1)) + 60 * int(mobj.group(2)) + float(mobj.group(3).replace(':', '.'))
2122
2123
2124 def srt_subtitles_timecode(seconds):
2125     return '%02d:%02d:%02d,%03d' % (seconds / 3600, (seconds % 3600) / 60, seconds % 60, (seconds % 1) * 1000)
2126
2127
2128 def dfxp2srt(dfxp_data):
2129     _x = functools.partial(xpath_with_ns, ns_map={
2130         'ttml': 'http://www.w3.org/ns/ttml',
2131         'ttaf1': 'http://www.w3.org/2006/10/ttaf1',
2132     })
2133
2134     class TTMLPElementParser(object):
2135         out = ''
2136
2137         def start(self, tag, attrib):
2138             if tag in (_x('ttml:br'), _x('ttaf1:br'), 'br'):
2139                 self.out += '\n'
2140
2141         def end(self, tag):
2142             pass
2143
2144         def data(self, data):
2145             self.out += data
2146
2147         def close(self):
2148             return self.out.strip()
2149
2150     def parse_node(node):
2151         target = TTMLPElementParser()
2152         parser = xml.etree.ElementTree.XMLParser(target=target)
2153         parser.feed(xml.etree.ElementTree.tostring(node))
2154         return parser.close()
2155
2156     dfxp = compat_etree_fromstring(dfxp_data.encode('utf-8'))
2157     out = []
2158     paras = dfxp.findall(_x('.//ttml:p')) or dfxp.findall(_x('.//ttaf1:p')) or dfxp.findall('.//p')
2159
2160     if not paras:
2161         raise ValueError('Invalid dfxp/TTML subtitle')
2162
2163     for para, index in zip(paras, itertools.count(1)):
2164         begin_time = parse_dfxp_time_expr(para.attrib.get('begin'))
2165         end_time = parse_dfxp_time_expr(para.attrib.get('end'))
2166         dur = parse_dfxp_time_expr(para.attrib.get('dur'))
2167         if begin_time is None:
2168             continue
2169         if not end_time:
2170             if not dur:
2171                 continue
2172             end_time = begin_time + dur
2173         out.append('%d\n%s --> %s\n%s\n\n' % (
2174             index,
2175             srt_subtitles_timecode(begin_time),
2176             srt_subtitles_timecode(end_time),
2177             parse_node(para)))
2178
2179     return ''.join(out)
2180
2181
2182 def cli_option(params, command_option, param):
2183     param = params.get(param)
2184     return [command_option, param] if param is not None else []
2185
2186
2187 def cli_bool_option(params, command_option, param, true_value='true', false_value='false', separator=None):
2188     param = params.get(param)
2189     assert isinstance(param, bool)
2190     if separator:
2191         return [command_option + separator + (true_value if param else false_value)]
2192     return [command_option, true_value if param else false_value]
2193
2194
2195 def cli_valueless_option(params, command_option, param, expected_value=True):
2196     param = params.get(param)
2197     return [command_option] if param == expected_value else []
2198
2199
2200 def cli_configuration_args(params, param, default=[]):
2201     ex_args = params.get(param)
2202     if ex_args is None:
2203         return default
2204     assert isinstance(ex_args, list)
2205     return ex_args
2206
2207
2208 class ISO639Utils(object):
2209     # See http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
2210     _lang_map = {
2211         'aa': 'aar',
2212         'ab': 'abk',
2213         'ae': 'ave',
2214         'af': 'afr',
2215         'ak': 'aka',
2216         'am': 'amh',
2217         'an': 'arg',
2218         'ar': 'ara',
2219         'as': 'asm',
2220         'av': 'ava',
2221         'ay': 'aym',
2222         'az': 'aze',
2223         'ba': 'bak',
2224         'be': 'bel',
2225         'bg': 'bul',
2226         'bh': 'bih',
2227         'bi': 'bis',
2228         'bm': 'bam',
2229         'bn': 'ben',
2230         'bo': 'bod',
2231         'br': 'bre',
2232         'bs': 'bos',
2233         'ca': 'cat',
2234         'ce': 'che',
2235         'ch': 'cha',
2236         'co': 'cos',
2237         'cr': 'cre',
2238         'cs': 'ces',
2239         'cu': 'chu',
2240         'cv': 'chv',
2241         'cy': 'cym',
2242         'da': 'dan',
2243         'de': 'deu',
2244         'dv': 'div',
2245         'dz': 'dzo',
2246         'ee': 'ewe',
2247         'el': 'ell',
2248         'en': 'eng',
2249         'eo': 'epo',
2250         'es': 'spa',
2251         'et': 'est',
2252         'eu': 'eus',
2253         'fa': 'fas',
2254         'ff': 'ful',
2255         'fi': 'fin',
2256         'fj': 'fij',
2257         'fo': 'fao',
2258         'fr': 'fra',
2259         'fy': 'fry',
2260         'ga': 'gle',
2261         'gd': 'gla',
2262         'gl': 'glg',
2263         'gn': 'grn',
2264         'gu': 'guj',
2265         'gv': 'glv',
2266         'ha': 'hau',
2267         'he': 'heb',
2268         'hi': 'hin',
2269         'ho': 'hmo',
2270         'hr': 'hrv',
2271         'ht': 'hat',
2272         'hu': 'hun',
2273         'hy': 'hye',
2274         'hz': 'her',
2275         'ia': 'ina',
2276         'id': 'ind',
2277         'ie': 'ile',
2278         'ig': 'ibo',
2279         'ii': 'iii',
2280         'ik': 'ipk',
2281         'io': 'ido',
2282         'is': 'isl',
2283         'it': 'ita',
2284         'iu': 'iku',
2285         'ja': 'jpn',
2286         'jv': 'jav',
2287         'ka': 'kat',
2288         'kg': 'kon',
2289         'ki': 'kik',
2290         'kj': 'kua',
2291         'kk': 'kaz',
2292         'kl': 'kal',
2293         'km': 'khm',
2294         'kn': 'kan',
2295         'ko': 'kor',
2296         'kr': 'kau',
2297         'ks': 'kas',
2298         'ku': 'kur',
2299         'kv': 'kom',
2300         'kw': 'cor',
2301         'ky': 'kir',
2302         'la': 'lat',
2303         'lb': 'ltz',
2304         'lg': 'lug',
2305         'li': 'lim',
2306         'ln': 'lin',
2307         'lo': 'lao',
2308         'lt': 'lit',
2309         'lu': 'lub',
2310         'lv': 'lav',
2311         'mg': 'mlg',
2312         'mh': 'mah',
2313         'mi': 'mri',
2314         'mk': 'mkd',
2315         'ml': 'mal',
2316         'mn': 'mon',
2317         'mr': 'mar',
2318         'ms': 'msa',
2319         'mt': 'mlt',
2320         'my': 'mya',
2321         'na': 'nau',
2322         'nb': 'nob',
2323         'nd': 'nde',
2324         'ne': 'nep',
2325         'ng': 'ndo',
2326         'nl': 'nld',
2327         'nn': 'nno',
2328         'no': 'nor',
2329         'nr': 'nbl',
2330         'nv': 'nav',
2331         'ny': 'nya',
2332         'oc': 'oci',
2333         'oj': 'oji',
2334         'om': 'orm',
2335         'or': 'ori',
2336         'os': 'oss',
2337         'pa': 'pan',
2338         'pi': 'pli',
2339         'pl': 'pol',
2340         'ps': 'pus',
2341         'pt': 'por',
2342         'qu': 'que',
2343         'rm': 'roh',
2344         'rn': 'run',
2345         'ro': 'ron',
2346         'ru': 'rus',
2347         'rw': 'kin',
2348         'sa': 'san',
2349         'sc': 'srd',
2350         'sd': 'snd',
2351         'se': 'sme',
2352         'sg': 'sag',
2353         'si': 'sin',
2354         'sk': 'slk',
2355         'sl': 'slv',
2356         'sm': 'smo',
2357         'sn': 'sna',
2358         'so': 'som',
2359         'sq': 'sqi',
2360         'sr': 'srp',
2361         'ss': 'ssw',
2362         'st': 'sot',
2363         'su': 'sun',
2364         'sv': 'swe',
2365         'sw': 'swa',
2366         'ta': 'tam',
2367         'te': 'tel',
2368         'tg': 'tgk',
2369         'th': 'tha',
2370         'ti': 'tir',
2371         'tk': 'tuk',
2372         'tl': 'tgl',
2373         'tn': 'tsn',
2374         'to': 'ton',
2375         'tr': 'tur',
2376         'ts': 'tso',
2377         'tt': 'tat',
2378         'tw': 'twi',
2379         'ty': 'tah',
2380         'ug': 'uig',
2381         'uk': 'ukr',
2382         'ur': 'urd',
2383         'uz': 'uzb',
2384         've': 'ven',
2385         'vi': 'vie',
2386         'vo': 'vol',
2387         'wa': 'wln',
2388         'wo': 'wol',
2389         'xh': 'xho',
2390         'yi': 'yid',
2391         'yo': 'yor',
2392         'za': 'zha',
2393         'zh': 'zho',
2394         'zu': 'zul',
2395     }
2396
2397     @classmethod
2398     def short2long(cls, code):
2399         """Convert language code from ISO 639-1 to ISO 639-2/T"""
2400         return cls._lang_map.get(code[:2])
2401
2402     @classmethod
2403     def long2short(cls, code):
2404         """Convert language code from ISO 639-2/T to ISO 639-1"""
2405         for short_name, long_name in cls._lang_map.items():
2406             if long_name == code:
2407                 return short_name
2408
2409
2410 class ISO3166Utils(object):
2411     # From http://data.okfn.org/data/core/country-list
2412     _country_map = {
2413         'AF': 'Afghanistan',
2414         'AX': 'Åland Islands',
2415         'AL': 'Albania',
2416         'DZ': 'Algeria',
2417         'AS': 'American Samoa',
2418         'AD': 'Andorra',
2419         'AO': 'Angola',
2420         'AI': 'Anguilla',
2421         'AQ': 'Antarctica',
2422         'AG': 'Antigua and Barbuda',
2423         'AR': 'Argentina',
2424         'AM': 'Armenia',
2425         'AW': 'Aruba',
2426         'AU': 'Australia',
2427         'AT': 'Austria',
2428         'AZ': 'Azerbaijan',
2429         'BS': 'Bahamas',
2430         'BH': 'Bahrain',
2431         'BD': 'Bangladesh',
2432         'BB': 'Barbados',
2433         'BY': 'Belarus',
2434         'BE': 'Belgium',
2435         'BZ': 'Belize',
2436         'BJ': 'Benin',
2437         'BM': 'Bermuda',
2438         'BT': 'Bhutan',
2439         'BO': 'Bolivia, Plurinational State of',
2440         'BQ': 'Bonaire, Sint Eustatius and Saba',
2441         'BA': 'Bosnia and Herzegovina',
2442         'BW': 'Botswana',
2443         'BV': 'Bouvet Island',
2444         'BR': 'Brazil',
2445         'IO': 'British Indian Ocean Territory',
2446         'BN': 'Brunei Darussalam',
2447         'BG': 'Bulgaria',
2448         'BF': 'Burkina Faso',
2449         'BI': 'Burundi',
2450         'KH': 'Cambodia',
2451         'CM': 'Cameroon',
2452         'CA': 'Canada',
2453         'CV': 'Cape Verde',
2454         'KY': 'Cayman Islands',
2455         'CF': 'Central African Republic',
2456         'TD': 'Chad',
2457         'CL': 'Chile',
2458         'CN': 'China',
2459         'CX': 'Christmas Island',
2460         'CC': 'Cocos (Keeling) Islands',
2461         'CO': 'Colombia',
2462         'KM': 'Comoros',
2463         'CG': 'Congo',
2464         'CD': 'Congo, the Democratic Republic of the',
2465         'CK': 'Cook Islands',
2466         'CR': 'Costa Rica',
2467         'CI': 'Côte d\'Ivoire',
2468         'HR': 'Croatia',
2469         'CU': 'Cuba',
2470         'CW': 'Curaçao',
2471         'CY': 'Cyprus',
2472         'CZ': 'Czech Republic',
2473         'DK': 'Denmark',
2474         'DJ': 'Djibouti',
2475         'DM': 'Dominica',
2476         'DO': 'Dominican Republic',
2477         'EC': 'Ecuador',
2478         'EG': 'Egypt',
2479         'SV': 'El Salvador',
2480         'GQ': 'Equatorial Guinea',
2481         'ER': 'Eritrea',
2482         'EE': 'Estonia',
2483         'ET': 'Ethiopia',
2484         'FK': 'Falkland Islands (Malvinas)',
2485         'FO': 'Faroe Islands',
2486         'FJ': 'Fiji',
2487         'FI': 'Finland',
2488         'FR': 'France',
2489         'GF': 'French Guiana',
2490         'PF': 'French Polynesia',
2491         'TF': 'French Southern Territories',
2492         'GA': 'Gabon',
2493         'GM': 'Gambia',
2494         'GE': 'Georgia',
2495         'DE': 'Germany',
2496         'GH': 'Ghana',
2497         'GI': 'Gibraltar',
2498         'GR': 'Greece',
2499         'GL': 'Greenland',
2500         'GD': 'Grenada',
2501         'GP': 'Guadeloupe',
2502         'GU': 'Guam',
2503         'GT': 'Guatemala',
2504         'GG': 'Guernsey',
2505         'GN': 'Guinea',
2506         'GW': 'Guinea-Bissau',
2507         'GY': 'Guyana',
2508         'HT': 'Haiti',
2509         'HM': 'Heard Island and McDonald Islands',
2510         'VA': 'Holy See (Vatican City State)',
2511         'HN': 'Honduras',
2512         'HK': 'Hong Kong',
2513         'HU': 'Hungary',
2514         'IS': 'Iceland',
2515         'IN': 'India',
2516         'ID': 'Indonesia',
2517         'IR': 'Iran, Islamic Republic of',
2518         'IQ': 'Iraq',
2519         'IE': 'Ireland',
2520         'IM': 'Isle of Man',
2521         'IL': 'Israel',
2522         'IT': 'Italy',
2523         'JM': 'Jamaica',
2524         'JP': 'Japan',
2525         'JE': 'Jersey',
2526         'JO': 'Jordan',
2527         'KZ': 'Kazakhstan',
2528         'KE': 'Kenya',
2529         'KI': 'Kiribati',
2530         'KP': 'Korea, Democratic People\'s Republic of',
2531         'KR': 'Korea, Republic of',
2532         'KW': 'Kuwait',
2533         'KG': 'Kyrgyzstan',
2534         'LA': 'Lao People\'s Democratic Republic',
2535         'LV': 'Latvia',
2536         'LB': 'Lebanon',
2537         'LS': 'Lesotho',
2538         'LR': 'Liberia',
2539         'LY': 'Libya',
2540         'LI': 'Liechtenstein',
2541         'LT': 'Lithuania',
2542         'LU': 'Luxembourg',
2543         'MO': 'Macao',
2544         'MK': 'Macedonia, the Former Yugoslav Republic of',
2545         'MG': 'Madagascar',
2546         'MW': 'Malawi',
2547         'MY': 'Malaysia',
2548         'MV': 'Maldives',
2549         'ML': 'Mali',
2550         'MT': 'Malta',
2551         'MH': 'Marshall Islands',
2552         'MQ': 'Martinique',
2553         'MR': 'Mauritania',
2554         'MU': 'Mauritius',
2555         'YT': 'Mayotte',
2556         'MX': 'Mexico',
2557         'FM': 'Micronesia, Federated States of',
2558         'MD': 'Moldova, Republic of',
2559         'MC': 'Monaco',
2560         'MN': 'Mongolia',
2561         'ME': 'Montenegro',
2562         'MS': 'Montserrat',
2563         'MA': 'Morocco',
2564         'MZ': 'Mozambique',
2565         'MM': 'Myanmar',
2566         'NA': 'Namibia',
2567         'NR': 'Nauru',
2568         'NP': 'Nepal',
2569         'NL': 'Netherlands',
2570         'NC': 'New Caledonia',
2571         'NZ': 'New Zealand',
2572         'NI': 'Nicaragua',
2573         'NE': 'Niger',
2574         'NG': 'Nigeria',
2575         'NU': 'Niue',
2576         'NF': 'Norfolk Island',
2577         'MP': 'Northern Mariana Islands',
2578         'NO': 'Norway',
2579         'OM': 'Oman',
2580         'PK': 'Pakistan',
2581         'PW': 'Palau',
2582         'PS': 'Palestine, State of',
2583         'PA': 'Panama',
2584         'PG': 'Papua New Guinea',
2585         'PY': 'Paraguay',
2586         'PE': 'Peru',
2587         'PH': 'Philippines',
2588         'PN': 'Pitcairn',
2589         'PL': 'Poland',
2590         'PT': 'Portugal',
2591         'PR': 'Puerto Rico',
2592         'QA': 'Qatar',
2593         'RE': 'Réunion',
2594         'RO': 'Romania',
2595         'RU': 'Russian Federation',
2596         'RW': 'Rwanda',
2597         'BL': 'Saint Barthélemy',
2598         'SH': 'Saint Helena, Ascension and Tristan da Cunha',
2599         'KN': 'Saint Kitts and Nevis',
2600         'LC': 'Saint Lucia',
2601         'MF': 'Saint Martin (French part)',
2602         'PM': 'Saint Pierre and Miquelon',
2603         'VC': 'Saint Vincent and the Grenadines',
2604         'WS': 'Samoa',
2605         'SM': 'San Marino',
2606         'ST': 'Sao Tome and Principe',
2607         'SA': 'Saudi Arabia',
2608         'SN': 'Senegal',
2609         'RS': 'Serbia',
2610         'SC': 'Seychelles',
2611         'SL': 'Sierra Leone',
2612         'SG': 'Singapore',
2613         'SX': 'Sint Maarten (Dutch part)',
2614         'SK': 'Slovakia',
2615         'SI': 'Slovenia',
2616         'SB': 'Solomon Islands',
2617         'SO': 'Somalia',
2618         'ZA': 'South Africa',
2619         'GS': 'South Georgia and the South Sandwich Islands',
2620         'SS': 'South Sudan',
2621         'ES': 'Spain',
2622         'LK': 'Sri Lanka',
2623         'SD': 'Sudan',
2624         'SR': 'Suriname',
2625         'SJ': 'Svalbard and Jan Mayen',
2626         'SZ': 'Swaziland',
2627         'SE': 'Sweden',
2628         'CH': 'Switzerland',
2629         'SY': 'Syrian Arab Republic',
2630         'TW': 'Taiwan, Province of China',
2631         'TJ': 'Tajikistan',
2632         'TZ': 'Tanzania, United Republic of',
2633         'TH': 'Thailand',
2634         'TL': 'Timor-Leste',
2635         'TG': 'Togo',
2636         'TK': 'Tokelau',
2637         'TO': 'Tonga',
2638         'TT': 'Trinidad and Tobago',
2639         'TN': 'Tunisia',
2640         'TR': 'Turkey',
2641         'TM': 'Turkmenistan',
2642         'TC': 'Turks and Caicos Islands',
2643         'TV': 'Tuvalu',
2644         'UG': 'Uganda',
2645         'UA': 'Ukraine',
2646         'AE': 'United Arab Emirates',
2647         'GB': 'United Kingdom',
2648         'US': 'United States',
2649         'UM': 'United States Minor Outlying Islands',
2650         'UY': 'Uruguay',
2651         'UZ': 'Uzbekistan',
2652         'VU': 'Vanuatu',
2653         'VE': 'Venezuela, Bolivarian Republic of',
2654         'VN': 'Viet Nam',
2655         'VG': 'Virgin Islands, British',
2656         'VI': 'Virgin Islands, U.S.',
2657         'WF': 'Wallis and Futuna',
2658         'EH': 'Western Sahara',
2659         'YE': 'Yemen',
2660         'ZM': 'Zambia',
2661         'ZW': 'Zimbabwe',
2662     }
2663
2664     @classmethod
2665     def short2full(cls, code):
2666         """Convert an ISO 3166-2 country code to the corresponding full name"""
2667         return cls._country_map.get(code.upper())
2668
2669
2670 class PerRequestProxyHandler(compat_urllib_request.ProxyHandler):
2671     def __init__(self, proxies=None):
2672         # Set default handlers
2673         for type in ('http', 'https'):
2674             setattr(self, '%s_open' % type,
2675                     lambda r, proxy='__noproxy__', type=type, meth=self.proxy_open:
2676                         meth(r, proxy, type))
2677         return compat_urllib_request.ProxyHandler.__init__(self, proxies)
2678
2679     def proxy_open(self, req, proxy, type):
2680         req_proxy = req.headers.get('Ytdl-request-proxy')
2681         if req_proxy is not None:
2682             proxy = req_proxy
2683             del req.headers['Ytdl-request-proxy']
2684
2685         if proxy == '__noproxy__':
2686             return None  # No Proxy
2687         return compat_urllib_request.ProxyHandler.proxy_open(
2688             self, req, proxy, type)
2689
2690
2691 def ohdave_rsa_encrypt(data, exponent, modulus):
2692     '''
2693     Implement OHDave's RSA algorithm. See http://www.ohdave.com/rsa/
2694
2695     Input:
2696         data: data to encrypt, bytes-like object
2697         exponent, modulus: parameter e and N of RSA algorithm, both integer
2698     Output: hex string of encrypted data
2699
2700     Limitation: supports one block encryption only
2701     '''
2702
2703     payload = int(binascii.hexlify(data[::-1]), 16)
2704     encrypted = pow(payload, exponent, modulus)
2705     return '%x' % encrypted
2706
2707
2708 def encode_base_n(num, n, table=None):
2709     FULL_TABLE = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
2710     if not table:
2711         table = FULL_TABLE[:n]
2712
2713     if n > len(table):
2714         raise ValueError('base %d exceeds table length %d' % (n, len(table)))
2715
2716     if num == 0:
2717         return table[0]
2718
2719     ret = ''
2720     while num:
2721         ret = table[num % n] + ret
2722         num = num // n
2723     return ret
2724
2725
2726 def decode_packed_codes(code):
2727     mobj = re.search(
2728         r"}\('(.+)',(\d+),(\d+),'([^']+)'\.split\('\|'\)",
2729         code)
2730     obfucasted_code, base, count, symbols = mobj.groups()
2731     base = int(base)
2732     count = int(count)
2733     symbols = symbols.split('|')
2734     symbol_table = {}
2735
2736     while count:
2737         count -= 1
2738         base_n_count = encode_base_n(count, base)
2739         symbol_table[base_n_count] = symbols[count] or base_n_count
2740
2741     return re.sub(
2742         r'\b(\w+)\b', lambda mobj: symbol_table[mobj.group(0)],
2743         obfucasted_code)