RubyGems - libv8 - Versions diffs - 7.3.492.27.1 → 8.4.255.0 - Mend

libv8 7.3.492.27.1 → 8.4.255.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (718) hide show

data/vendor/depot_tools/third_party/colorama/README.txt DELETED

@@ -1,304 +0,0 @@
-Download and docs:
-    http://pypi.python.org/pypi/colorama
-Development:
-    http://code.google.com/p/colorama
-Discussion group:
-     https://groups.google.com/forum/#!forum/python-colorama
-Description
-===========
-Makes ANSI escape character sequences for producing colored terminal text and
-cursor positioning work under MS Windows.
-ANSI escape character sequences have long been used to produce colored terminal
-text and cursor positioning on Unix and Macs. Colorama makes this work on
-Windows, too, by wrapping stdout, stripping ANSI sequences it finds (which
-otherwise show up as gobbledygook in your output), and converting them into the
-appropriate win32 calls to modify the state of the terminal. On other platforms,
-Colorama does nothing.
-Colorama also provides some shortcuts to help generate ANSI sequences
-but works fine in conjunction with any other ANSI sequence generation library,
-such as Termcolor (http://pypi.python.org/pypi/termcolor.)
-This has the upshot of providing a simple cross-platform API for printing
-colored terminal text from Python, and has the happy side-effect that existing
-applications or libraries which use ANSI sequences to produce colored output on
-Linux or Macs can now also work on Windows, simply by calling
-``colorama.init()``.
-An alternative approach is to install 'ansi.sys' on Windows machines, which
-provides the same behaviour for all applications running in terminals. Colorama
-is intended for situations where that isn't easy (e.g. maybe your app doesn't
-have an installer.)
-Demo scripts in the source code repository prints some colored text using
-ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
-handling, versus on Windows Command-Prompt using Colorama:
-.. image:: http://colorama.googlecode.com/hg/screenshots/ubuntu-demo.png
-    :width: 661
-    :height: 357
-    :alt: ANSI sequences on Ubuntu under gnome-terminal.
-.. image:: http://colorama.googlecode.com/hg/screenshots/windows-demo.png
-    :width: 668
-    :height: 325
-    :alt: Same ANSI sequences on Windows, using Colorama.
-These screengrabs show that Colorama on Windows does not support ANSI 'dim
-text': it looks the same as 'normal text'.
-License
-=======
-Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
-Dependencies
-============
-None, other than Python. Tested on Python 2.5.5, 2.6.5, 2.7, 3.1.2, and 3.2
-Usage
-=====
-Initialisation
---------------
-Applications should initialise Colorama using::
-    from colorama import init
-    init()
-If you are on Windows, the call to ``init()`` will start filtering ANSI escape
-sequences out of any text sent to stdout or stderr, and will replace them with
-equivalent Win32 calls.
-Calling ``init()`` has no effect on other platforms (unless you request other
-optional functionality, see keyword args below.) The intention is that
-applications can call ``init()`` unconditionally on all platforms, after which
-ANSI output should just work.
-To stop using colorama before your program exits, simply call ``deinit()``.
-This will restore stdout and stderr to their original values, so that Colorama
-is disabled. To start using Colorama again, call ``reinit()``, which wraps
-stdout and stderr again, but is cheaper to call than doing ``init()`` all over
-again.
-Colored Output
---------------
-Cross-platform printing of colored text can then be done using Colorama's
-constant shorthand for ANSI escape sequences::
-    from colorama import Fore, Back, Style
-    print(Fore.RED + 'some red text')
-    print(Back.GREEN + 'and with a green background')
-    print(Style.DIM + 'and in dim text')
-    print(Fore.RESET + Back.RESET + Style.RESET_ALL)
-    print('back to normal now')
-or simply by manually printing ANSI sequences from your own code::
-    print('/033[31m' + 'some red text')
-    print('/033[30m' # and reset to default color)
-or Colorama can be used happily in conjunction with existing ANSI libraries
-such as Termcolor::
-    from colorama import init
-    from termcolor import colored
-    # use Colorama to make Termcolor work on Windows too
-    init()
-    # then use Termcolor for all colored text output
-    print(colored('Hello, World!', 'green', 'on_red'))
-Available formatting constants are::
-    Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
-    Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
-    Style: DIM, NORMAL, BRIGHT, RESET_ALL
-Style.RESET_ALL resets foreground, background and brightness. Colorama will
-perform this reset automatically on program exit.
-Cursor Positioning
-------------------
-ANSI codes to reposition the cursor are supported. See demos/demo06.py for
-an example of how to generate them.
-Init Keyword Args
------------------
-``init()`` accepts some kwargs to override default behaviour.
-init(autoreset=False):
-    If you find yourself repeatedly sending reset sequences to turn off color
-    changes at the end of every print, then ``init(autoreset=True)`` will
-    automate that::
-        from colorama import init
-        init(autoreset=True)
-        print(Fore.RED + 'some red text')
-        print('automatically back to default color again')
-init(strip=None):
-    Pass ``True`` or ``False`` to override whether ansi codes should be
-    stripped from the output. The default behaviour is to strip if on Windows.
-init(convert=None):
-    Pass ``True`` or ``False`` to override whether to convert ansi codes in the
-    output into win32 calls. The default behaviour is to convert if on Windows
-    and output is to a tty (terminal).
-init(wrap=True):
-    On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr``
-    with proxy objects, which override the .write() method to do their work. If
-    this wrapping causes you problems, then this can be disabled by passing
-    ``init(wrap=False)``. The default behaviour is to wrap if autoreset or
-    strip or convert are True.
-    When wrapping is disabled, colored printing on non-Windows platforms will
-    continue to work as normal. To do cross-platform colored output, you can
-    use Colorama's ``AnsiToWin32`` proxy directly::
-        import sys
-        from colorama import init, AnsiToWin32
-        init(wrap=False)
-        stream = AnsiToWin32(sys.stderr).stream
-        # Python 2
-        print >>stream, Fore.BLUE + 'blue text on stderr'
-        # Python 3
-        print(Fore.BLUE + 'blue text on stderr', file=stream)
-Status & Known Problems
-=======================
-I've personally only tested it on WinXP (CMD, Console2), Ubuntu
-(gnome-terminal, xterm), and OSX.
-Some presumably valid ANSI sequences aren't recognised (see details below)
-but to my knowledge nobody has yet complained about this. Puzzling.
-See outstanding issues and wishlist at:
-http://code.google.com/p/colorama/issues/list
-If anything doesn't work for you, or doesn't do what you expected or hoped for,
-I'd love to hear about it on that issues list, would be delighted by patches,
-and would be happy to grant commit access to anyone who submits a working patch
-or two.
-Recognised ANSI Sequences
-=========================
-ANSI sequences generally take the form:
-    ESC [ <param> ; <param> ... <command>
-Where <param> is an integer, and <command> is a single letter. Zero or more
-params are passed to a <command>. If no params are passed, it is generally
-synonymous with passing a single zero. No spaces exist in the sequence, they
-have just been inserted here to make it easy to read.
-The only ANSI sequences that colorama converts into win32 calls are::
-    ESC [ 0 m       # reset all (colors and brightness)
-    ESC [ 1 m       # bright
-    ESC [ 2 m       # dim (looks same as normal brightness)
-    ESC [ 22 m      # normal brightness
-    # FOREGROUND:
-    ESC [ 30 m      # black
-    ESC [ 31 m      # red
-    ESC [ 32 m      # green
-    ESC [ 33 m      # yellow
-    ESC [ 34 m      # blue
-    ESC [ 35 m      # magenta
-    ESC [ 36 m      # cyan
-    ESC [ 37 m      # white
-    ESC [ 39 m      # reset
-    # BACKGROUND
-    ESC [ 40 m      # black
-    ESC [ 41 m      # red
-    ESC [ 42 m      # green
-    ESC [ 43 m      # yellow
-    ESC [ 44 m      # blue
-    ESC [ 45 m      # magenta
-    ESC [ 46 m      # cyan
-    ESC [ 47 m      # white
-    ESC [ 49 m      # reset
-    # cursor positioning
-    ESC [ y;x H     # position cursor at x across, y down
-    # clear the screen
-    ESC [ mode J    # clear the screen. Only mode 2 (clear entire screen)
-                    # is supported. It should be easy to add other modes,
-                    # let me know if that would be useful.
-Multiple numeric params to the 'm' command can be combined into a single
-sequence, eg::
-    ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background
-All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
-are silently stripped from the output on Windows.
-Any other form of ANSI sequence, such as single-character codes or alternative
-initial characters, are not recognised nor stripped. It would be cool to add
-them though. Let me know if it would be useful for you, via the issues on
-google code.
-Development
-===========
-Help and fixes welcome! Ask Jonathan for commit rights, you'll get them.
-Running tests requires:
-- Michael Foord's 'mock' module to be installed.
-- Tests are written using the 2010 era updates to 'unittest', and require to
-  be run either using Python2.7 or greater, or else to have Michael Foord's
-  'unittest2' module installed.
-unittest2 test discovery doesn't work for colorama, so I use 'nose'::
-    nosetests -s
-The -s is required because 'nosetests' otherwise applies a proxy of its own to
-stdout, which confuses the unit tests.
-Contact
-=======
-Created by Jonathan Hartley, tartley@tartley.com
-Thanks
-======
-| Ben Hoyt, for a magnificent fix under 64-bit Windows.
-| Jesse@EmptySquare for submitting a fix for examples in the README.
-| User 'jamessp', an observant documentation fix for cursor positioning.
-| User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7 fix.
-| Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
-| Daniel Griffith for multiple fabulous patches.
-| Oscar Lesta for valuable fix to stop ANSI chars being sent to non-tty output.
-| Roger Binns, for many suggestions, valuable feedback, & bug reports.
-| Tim Golden for thought and much appreciated feedback on the initial idea.

data/vendor/depot_tools/third_party/fancy_urllib/README DELETED

@@ -1,22 +0,0 @@
-The fancy_urllib library was obtained from [1] under the following
-license ([2]):
-GOOGLE APP ENGINE SDK
-=====================
-Copyright 2008 Google Inc.
-All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-[1] https://github.com/GoogleCloudPlatform/appengine-python-vm-runtime/blob/master/python_vm_runtime/lib/fancy_urllib/fancy_urllib/__init__.py
-[2] https://github.com/GoogleCloudPlatform/appengine-python-vm-runtime/blob/master/python_vm_runtime/LICENSE

data/vendor/depot_tools/third_party/fancy_urllib/__init__.py DELETED

@@ -1,460 +0,0 @@
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Python Software
-# Foundation; All Rights Reserved
-"""A HTTPSConnection/Handler with additional proxy and cert validation features.
-In particular, monkey patches in Python r74203 to provide support for CONNECT
-proxies and adds SSL cert validation if the ssl module is present.
-"""
-__author__ = "{frew,nick.johnson}@google.com (Fred Wulff and Nick Johnson)"
-import base64
-import httplib
-import logging
-import socket
-from urllib import splitpasswd
-from urllib import splittype
-from urllib import splituser
-import urllib2
-class InvalidCertificateException(httplib.HTTPException):
-  """Raised when a certificate is provided with an invalid hostname."""
-  def __init__(self, host, cert, reason):
-    """Constructor.
-    Args:
-      host: The hostname the connection was made to.
-      cert: The SSL certificate (as a dictionary) the host returned.
-      reason: user readable error reason.
-    """
-    httplib.HTTPException.__init__(self)
-    self.host = host
-    self.cert = cert
-    self.reason = reason
-  def __str__(self):
-    return ("Host %s returned an invalid certificate (%s): %s\n"
-            "To learn more, see "
-            "http://code.google.com/appengine/kb/general.html#rpcssl" %
-            (self.host, self.reason, self.cert))
-try:
-  import ssl
-  _CAN_VALIDATE_CERTS = True
-except ImportError:
-  _CAN_VALIDATE_CERTS = False
-def can_validate_certs():
-  """Return True if we have the SSL package and can validate certificates."""
-  return _CAN_VALIDATE_CERTS
-# Reexport SSLError so clients don't have to to do their own checking for ssl's
-# existence.
-if can_validate_certs():
-  SSLError = ssl.SSLError
-else:
-  SSLError = None
-def create_fancy_connection(tunnel_host=None, key_file=None,
-                            cert_file=None, ca_certs=None,
-                            proxy_authorization=None):
-  # This abomination brought to you by the fact that
-  # the HTTPHandler creates the connection instance in the middle
-  # of do_open so we need to add the tunnel host to the class.
-  class PresetProxyHTTPSConnection(httplib.HTTPSConnection):
-    """An HTTPS connection that uses a proxy defined by the enclosing scope."""
-    def __init__(self, *args, **kwargs):
-      httplib.HTTPSConnection.__init__(self, *args, **kwargs)
-      self._tunnel_host = tunnel_host
-      if tunnel_host:
-        logging.debug("Creating preset proxy https conn: %s", tunnel_host)
-      self.key_file = key_file
-      self.cert_file = cert_file
-      self.ca_certs = ca_certs
-      if can_validate_certs():
-        if self.ca_certs:
-          self.cert_reqs = ssl.CERT_REQUIRED
-        else:
-          self.cert_reqs = ssl.CERT_NONE
-    def _get_hostport(self, host, port):
-      # Python 2.7.7rc1 (hg r90728:568041fd8090), 3.4.1 and 3.5 rename
-      # _set_hostport to _get_hostport and changes it's functionality.  The
-      # Python 2.7.7rc1 version of this method is included here for
-      # compatibility with earlier versions of Python.  Without this, HTTPS over
-      # HTTP CONNECT proxies cannot be used.
-      # This method may be removed if compatibility with Python <2.7.7rc1 is not
-      # required.
-      # Python bug: http://bugs.python.org/issue7776
-      if port is None:
-        i = host.rfind(":")
-        j = host.rfind("]")         # ipv6 addresses have [...]
-        if i > j:
-          try:
-            port = int(host[i+1:])
-          except ValueError:
-            if host[i+1:] == "":  # http://foo.com:/ == http://foo.com/
-              port = self.default_port
-            else:
-              raise httplib.InvalidURL("nonnumeric port: '%s'" % host[i+1:])
-          host = host[:i]
-        else:
-          port = self.default_port
-        if host and host[0] == "[" and host[-1] == "]":
-          host = host[1:-1]
-      return (host, port)
-    def _tunnel(self):
-      self.host, self.port = self._get_hostport(self._tunnel_host, None)
-      logging.info("Connecting through tunnel to: %s:%d",
-                   self.host, self.port)
-      self.send("CONNECT %s:%d HTTP/1.0\r\n" % (self.host, self.port))
-      if proxy_authorization:
-        self.send("Proxy-Authorization: %s\r\n" % proxy_authorization)
-      # blank line
-      self.send("\r\n")
-      response = self.response_class(self.sock, strict=self.strict,
-                                     method=self._method)
-      # pylint: disable=protected-access
-      (_, code, message) = response._read_status()
-      if code != 200:
-        self.close()
-        raise socket.error("Tunnel connection failed: %d %s" %
-                           (code, message.strip()))
-      while True:
-        line = response.fp.readline()
-        if line == "\r\n":
-          break
-    def _get_valid_hosts_for_cert(self, cert):
-      """Returns a list of valid host globs for an SSL certificate.
-      Args:
-        cert: A dictionary representing an SSL certificate.
-      Returns:
-        list: A list of valid host globs.
-      """
-      if "subjectAltName" in cert:
-        return [x[1] for x in cert["subjectAltName"] if x[0].lower() == "dns"]
-      else:
-        # Return a list of commonName fields
-        return [x[0][1] for x in cert["subject"]
-                if x[0][0].lower() == "commonname"]
-    def _validate_certificate_hostname(self, cert, hostname):
-      """Perform RFC2818/6125 validation against a cert and hostname.
-      Args:
-        cert: A dictionary representing an SSL certificate.
-        hostname: The hostname to test.
-      Returns:
-        bool: Whether or not the hostname is valid for this certificate.
-      """
-      hosts = self._get_valid_hosts_for_cert(cert)
-      for host in hosts:
-        # Wildcards are only valid when the * exists at the end of the last
-        # (left-most) label, and there are at least 3 labels in the expression.
-        if ("*." in host and host.count("*") == 1 and
-            host.count(".") > 1 and "." in hostname):
-          left_expected, right_expected = host.split("*.")
-          left_hostname, right_hostname = hostname.split(".", 1)
-          if (left_hostname.startswith(left_expected) and
-              right_expected == right_hostname):
-            return True
-        elif host == hostname:
-          return True
-      return False
-    def connect(self):
-      # TODO(frew): When we drop support for <2.6 (in the far distant future),
-      # change this to socket.create_connection.
-      self.sock = _create_connection((self.host, self.port))
-      if self._tunnel_host:
-        self._tunnel()
-      # ssl and FakeSocket got deprecated. Try for the new hotness of wrap_ssl,
-      # with fallback. Note: Since can_validate_certs() just checks for the
-      # ssl module, it's equivalent to attempting to import ssl from
-      # the function, but doesn't require a dynamic import, which doesn't
-      # play nicely with dev_appserver.
-      if can_validate_certs():
-        self.sock = ssl.wrap_socket(self.sock,
-                                    keyfile=self.key_file,
-                                    certfile=self.cert_file,
-                                    ca_certs=self.ca_certs,
-                                    cert_reqs=self.cert_reqs)
-        if self.cert_reqs & ssl.CERT_REQUIRED:
-          cert = self.sock.getpeercert()
-          hostname = self.host.split(":", 0)[0]
-          if not self._validate_certificate_hostname(cert, hostname):
-            raise InvalidCertificateException(hostname, cert,
-                                              "hostname mismatch")
-      else:
-        ssl_socket = socket.ssl(self.sock,
-                                keyfile=self.key_file,
-                                certfile=self.cert_file)
-        self.sock = httplib.FakeSocket(self.sock, ssl_socket)
-  return PresetProxyHTTPSConnection
-# Here to end of _create_connection copied wholesale from Python 2.6"s socket.py
-_GLOBAL_DEFAULT_TIMEOUT = object()
-def _create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT):
-  """Connect to *address* and return the socket object.
-  Convenience function.  Connect to *address* (a 2-tuple ``(host,
-  port)``) and return the socket object.  Passing the optional
-  *timeout* parameter will set the timeout on the socket instance
-  before attempting to connect.  If no *timeout* is supplied, the
-  global default timeout setting returned by :func:`getdefaulttimeout`
-  is used.
-  """
-  msg = "getaddrinfo returns an empty list"
-  host, port = address
-  for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
-    af, socktype, proto, canonname, sa = res
-    sock = None
-    try:
-      sock = socket.socket(af, socktype, proto)
-      if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
-        sock.settimeout(timeout)
-      sock.connect(sa)
-      return sock
-    except socket.error, msg:
-      if sock is not None:
-        sock.close()
-  raise socket.error, msg
-class FancyRequest(urllib2.Request):
-  """A request that allows the use of a CONNECT proxy."""
-  def __init__(self, *args, **kwargs):
-    urllib2.Request.__init__(self, *args, **kwargs)
-    self._tunnel_host = None
-    self._key_file = None
-    self._cert_file = None
-    self._ca_certs = None
-  def set_proxy(self, host, type):
-    saved_type = None
-    if self.get_type() == "https" and not self._tunnel_host:
-      self._tunnel_host = self.get_host()
-      saved_type = self.get_type()
-    urllib2.Request.set_proxy(self, host, type)
-    if saved_type:
-      # Don't set self.type, we want to preserve the
-      # type for tunneling.
-      self.type = saved_type
-  def set_ssl_info(self, key_file=None, cert_file=None, ca_certs=None):
-    self._key_file = key_file
-    self._cert_file = cert_file
-    self._ca_certs = ca_certs
-class FancyProxyHandler(urllib2.ProxyHandler):
-  """A ProxyHandler that works with CONNECT-enabled proxies."""
-  # Taken verbatim from /usr/lib/python2.5/urllib2.py
-  def _parse_proxy(self, proxy):
-    """Return (scheme, user, password, host/port) given a URL or an authority.
-    If a URL is supplied, it must have an authority (host:port) component.
-    According to RFC 3986, having an authority component means the URL must
-    have two slashes after the scheme:
-    >>> _parse_proxy('file:/ftp.example.com/')
-    Traceback (most recent call last):
-    ValueError: proxy URL with no authority: 'file:/ftp.example.com/'
-    The first three items of the returned tuple may be None.
-    Examples of authority parsing:
-    >>> _parse_proxy('proxy.example.com')
-    (None, None, None, 'proxy.example.com')
-    >>> _parse_proxy('proxy.example.com:3128')
-    (None, None, None, 'proxy.example.com:3128')
-    The authority component may optionally include userinfo (assumed to be
-    username:password):
-    >>> _parse_proxy('joe:password@proxy.example.com')
-    (None, 'joe', 'password', 'proxy.example.com')
-    >>> _parse_proxy('joe:password@proxy.example.com:3128')
-    (None, 'joe', 'password', 'proxy.example.com:3128')
-    Same examples, but with URLs instead:
-    >>> _parse_proxy('http://proxy.example.com/')
-    ('http', None, None, 'proxy.example.com')
-    >>> _parse_proxy('http://proxy.example.com:3128/')
-    ('http', None, None, 'proxy.example.com:3128')
-    >>> _parse_proxy('http://joe:password@proxy.example.com/')
-    ('http', 'joe', 'password', 'proxy.example.com')
-    >>> _parse_proxy('http://joe:password@proxy.example.com:3128')
-    ('http', 'joe', 'password', 'proxy.example.com:3128')
-    Everything after the authority is ignored:
-    >>> _parse_proxy('ftp://joe:password@proxy.example.com/rubbish:3128')
-    ('ftp', 'joe', 'password', 'proxy.example.com')
-    Test for no trailing '/' case:
-    >>> _parse_proxy('http://joe:password@proxy.example.com')
-    ('http', 'joe', 'password', 'proxy.example.com')
-    """
-    scheme, r_scheme = splittype(proxy)
-    if not r_scheme.startswith("/"):
-      # authority
-      scheme = None
-      authority = proxy
-    else:
-      # URL
-      if not r_scheme.startswith("//"):
-        raise ValueError("proxy URL with no authority: %r" % proxy)
-      # We have an authority, so for RFC 3986-compliant URLs (by ss 3.
-      # and 3.3.), path is empty or starts with '/'
-      end = r_scheme.find("/", 2)
-      if end == -1:
-        end = None
-      authority = r_scheme[2:end]
-    userinfo, hostport = splituser(authority)
-    if userinfo is not None:
-      user, password = splitpasswd(userinfo)
-    else:
-      user = password = None
-    return scheme, user, password, hostport
-  def proxy_open(self, req, proxy, type):
-    # This block is copied wholesale from Python2.6 urllib2.
-    # It is idempotent, so the superclass method call executes as normal
-    # if invoked.
-    orig_type = req.get_type()
-    proxy_type, user, password, hostport = self._parse_proxy(proxy)
-    if proxy_type is None:
-      proxy_type = orig_type
-    if user and password:
-      user_pass = "%s:%s" % (urllib2.unquote(user), urllib2.unquote(password))
-      creds = base64.b64encode(user_pass).strip()
-      # Later calls overwrite earlier calls for the same header
-      req.add_header("Proxy-authorization", "Basic " + creds)
-    hostport = urllib2.unquote(hostport)
-    req.set_proxy(hostport, proxy_type)
-    # This condition is the change
-    if orig_type == "https":
-      return None
-    return urllib2.ProxyHandler.proxy_open(self, req, proxy, type)
-class FancyHTTPSHandler(urllib2.HTTPSHandler):
-  """An HTTPSHandler that works with CONNECT-enabled proxies."""
-  def do_open(self, http_class, req, *args, **kwargs):
-    proxy_authorization = None
-    for header in req.headers:
-      if header.lower() == "proxy-authorization":
-        proxy_authorization = req.headers[header]
-        break
-    # Intentionally very specific so as to opt for false negatives
-    # rather than false positives.
-    try:
-      return urllib2.HTTPSHandler.do_open(
-          self,
-          create_fancy_connection(req._tunnel_host,
-                                  req._key_file,
-                                  req._cert_file,
-                                  req._ca_certs,
-                                  proxy_authorization),
-          req, *args, **kwargs)
-    except urllib2.URLError, url_error:
-      try:
-        import ssl
-        if (type(url_error.reason) == ssl.SSLError and
-            url_error.reason.args[0] == 1):
-          # Display the reason to the user. Need to use args for python2.5
-          # compat.
-          raise InvalidCertificateException(req.host, "",
-                                            url_error.reason.args[1])
-      except ImportError:
-        pass
-      raise url_error
-# We have to implement this so that we persist the tunneling behavior
-# through redirects.
-class FancyRedirectHandler(urllib2.HTTPRedirectHandler):
-  """A redirect handler that persists CONNECT-enabled proxy information."""
-  def redirect_request(self, req, *args, **kwargs):
-    new_req = urllib2.HTTPRedirectHandler.redirect_request(
-        self, req, *args, **kwargs)
-    # Same thing as in our set_proxy implementation, but in this case
-    # we"ve only got a Request to work with, so it was this or copy
-    # everything over piecemeal.
-    #
-    # Note that we do not persist tunneling behavior from an http request
-    # to an https request, because an http request does not set _tunnel_host.
-    #
-    # Also note that in Python < 2.6, you will get an error in
-    # FancyHTTPSHandler.do_open() on an https urllib2.Request that uses an http
-    # proxy, since the proxy type will be set to http instead of https.
-    # (FancyRequest, and urllib2.Request in Python >= 2.6 set the proxy type to
-    # https.)  Such an urllib2.Request could result from this redirect
-    # if you are redirecting from an http request (since an an http request
-    # does not have _tunnel_host set, and thus you will not set the proxy
-    # in the code below), and if you have defined a proxy for https in, say,
-    # FancyProxyHandler, and that proxy has type http.
-    if hasattr(req, "_tunnel_host") and isinstance(new_req, urllib2.Request):
-      if new_req.get_type() == "https":
-        if req._tunnel_host:
-          # req is proxied, so copy the proxy info.
-          new_req._tunnel_host = new_req.get_host()
-          new_req.set_proxy(req.host, "https")
-        else:
-          # req is not proxied, so just make sure _tunnel_host is defined.
-          new_req._tunnel_host = None
-        new_req.type = "https"
-    if hasattr(req, "_key_file") and isinstance(new_req, urllib2.Request):
-      # Copy the auxiliary data in case this or any further redirect is https
-      new_req._key_file = req._key_file
-      new_req._cert_file = req._cert_file
-      new_req._ca_certs = req._ca_certs
-    return new_req