Update 'requests' lib to v2.0.

third_party/requests/packages/urllib3/response.py

 # urllib3/response.py
-# Copyright 2008-2012 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
+# Copyright 2008-2013 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
 #
 # This module is part of urllib3 and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 
 import logging
 import zlib
+import io
 
 from .exceptions import DecodeError
 from .packages.six import string_types as basestring, binary_type
+from .util import is_fp_closed
 
 
 log = logging.getLogger(__name__)
 
 
 class DeflateDecoder(object):
 
     def __init__(self):
         self._first_try = True
         self._data = binary_type()
@@ skipping 18 matching lines @@
                 self._data = None
 
 
 def _get_decoder(mode):
     if mode == 'gzip':
         return zlib.decompressobj(16 + zlib.MAX_WBITS)
 
     return DeflateDecoder()
 
 
-class HTTPResponse(object):
+class HTTPResponse(io.IOBase):
     """
     HTTP Response container.
 
     Backwards-compatible to httplib's HTTPResponse but the response ``body`` is
     loaded and decoded on-demand when the ``data`` property is accessed.
 
     Extra parameters for behaviour not present in httplib.HTTPResponse:
 
     :param preload_content:
         If True, the response's body will be preloaded during construction.
 
     :param decode_content:
         If True, attempts to decode specific content-encoding's based on headers
         (like 'gzip' and 'deflate') will be skipped and raw data will be used
         instead.
 
     :param original_response:
         When this HTTPResponse wrapper is generated from an httplib.HTTPResponse
         object, it's convenient to include the original for debug purposes. It's
         otherwise unused.
     """
 
     CONTENT_DECODERS = ['gzip', 'deflate']
+    REDIRECT_STATUSES = [301, 302, 303, 307, 308]
 
     def __init__(self, body='', headers=None, status=0, version=0, reason=None,
                  strict=0, preload_content=True, decode_content=True,
                  original_response=None, pool=None, connection=None):
         self.headers = headers or {}
         self.status = status
         self.version = version
         self.reason = reason
         self.strict = strict
         self.decode_content = decode_content
@@ skipping 13 matching lines @@
             self._body = self.read(decode_content=decode_content)
 
     def get_redirect_location(self):
         """
         Should we redirect and where to?
 
         :returns: Truthy redirect location string if we got a redirect status
             code and valid location. ``None`` if redirect status and no
             location. ``False`` if not a redirect status code.
         """
-        if self.status in [301, 302, 303, 307]:
+        if self.status in self.REDIRECT_STATUSES:
             return self.headers.get('location')
 
         return False
 
     def release_conn(self):
         if not self._pool or not self._connection:
             return
 
         self._pool._put_conn(self._connection)
         self._connection = None
@@ skipping 57 matching lines @@
                     # already do.  However, versions of python released before
                     # December 15, 2012 (http://bugs.python.org/issue16298) do not
                     # properly close the connection in all cases. There is no harm
                     # in redundantly calling close.
                     self._fp.close()
                     flush_decoder = True
 
             try:
                 if decode_content and self._decoder:
                     data = self._decoder.decompress(data)
-            except (IOError, zlib.error):
-                raise DecodeError("Received response with content-encoding: %s, but "
-                                  "failed to decode it." % content_encoding)
+            except (IOError, zlib.error) as e:
+                raise DecodeError(
+                    "Received response with content-encoding: %s, but "
+                    "failed to decode it." % content_encoding,
+                    e)
 
-            if flush_decoder and self._decoder:
+            if flush_decoder and decode_content and self._decoder:
                 buf = self._decoder.decompress(binary_type())
                 data += buf + self._decoder.flush()
 
             if cache_content:
                 self._body = data
 
             return data
 
         finally:
             if self._original_response and self._original_response.isclosed():
                 self.release_conn()
 
+    def stream(self, amt=2**16, decode_content=None):
+        """
+        A generator wrapper for the read() method. A call will block until
+        ``amt`` bytes have been read from the connection or until the
+        connection is closed.
+
+        :param amt:
+            How much of the content to read. The generator will return up to
+            much data per iteration, but may return less. This is particularly
+            likely when using compressed data. However, the empty string will
+            never be returned.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        while not is_fp_closed(self._fp):
+            data = self.read(amt=amt, decode_content=decode_content)
+
+            if data:
+                yield data
+
+
     @classmethod
     def from_httplib(ResponseCls, r, **response_kw):
         """
         Given an :class:`httplib.HTTPResponse` instance ``r``, return a
         corresponding :class:`urllib3.response.HTTPResponse` object.
 
         Remaining parameters are passed to the HTTPResponse constructor, along
         with ``original_response=r``.
         """
 
@@ skipping 19 matching lines @@
                            strict=strict,
                            original_response=r,
                            **response_kw)
 
     # Backwards-compatibility methods for httplib.HTTPResponse
     def getheaders(self):
         return self.headers
 
     def getheader(self, name, default=None):
         return self.headers.get(name, default)
+
+    # Overrides from io.IOBase
+    def close(self):
+        if not self.closed:
+            self._fp.close()
+
+    @property
+    def closed(self):
+        if self._fp is None:
+            return True
+        elif hasattr(self._fp, 'closed'):
+            return self._fp.closed
+        elif hasattr(self._fp, 'isclosed'):  # Python 2
+            return self._fp.isclosed()
+        else:
+            return True
+
+    def fileno(self):
+        if self._fp is None:
+            raise IOError("HTTPResponse has no file to get a fileno from")
+        elif hasattr(self._fp, "fileno"):
+            return self._fp.fileno()
+        else:
+            raise IOError("The file-like object  this HTTPResponse is wrapped "
+                          "around has no file descriptor")
+
+    def flush(self):
+        if self._fp is not None and hasattr(self._fp, 'flush'):
+            return self._fp.flush()
+
+    def readable(self):
+        return True