code: def read(self, amt=None, decode_content=True, cache_content=False):
          
          content_encoding = self.headers.get('content-encoding')
          decoder = self.CONTENT_DECODERS.get(content_encoding)
  
          data = self._fp and self._fp.read(amt)
  
          try:
  
              if amt:
                  return data
  
              if not decode_content or not decoder:
                  if cache_content:
                      self._body = data
  
                  return data
  
              try:
                  data = decoder(data)
              except IOError:
                  raise HTTPError("Received response with content-encoding: %s, but "
                                  "failed to decode it." % content_encoding)
  
              if cache_content:
                  self._body = data
  
              return data
  
          finally:
  
              if self._original_response and self._original_response.isclosed():
                  self.release_conn()
docs: Similar to :meth:`httplib.HTTPResponse.read`, but with two additional
          parameters: ``decode_content`` and ``cache_content``.
  
          :param amt:
              How much of the content to read. If specified, decoding and caching
              is skipped because we can't decode partial content nor does it make
              sense to cache partial content as the full response.
  
          :param decode_content:
              If True, will attempt to decode the body based on the
              'content-encoding' header. (Overridden if ``amt`` is set.)
  
          :param cache_content:
              If True, will save the returned data such that the same result is
              returned despite of the state of the underlying file object. This
              is useful if you want the ``.data`` property to continue working
              after having ``.read()`` the file object. (Overridden if ``amt`` is
              set.)