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

libv8 7.3.492.27.1 → 8.4.255.0

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