'Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) <timeouts>` tuple.
:type timeout: float or tuple
:param verify: (optional) Whether to verify SSL certificates.
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.'

def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):

    conn = self.get_connection(request.url, proxies)
    self.cert_verify(conn, request.url, verify, cert)
    url = self.request_url(request, proxies)
    self.add_headers(request)
    chunked = (not ((request.body is None) or ('Content-Length' in request.headers)))
    if isinstance(timeout, tuple):
        try:
            (connect, read) = timeout
            timeout = TimeoutSauce(connect=connect, read=read)
        except ValueError as e:
            err = 'Invalid    timeout    {0}.    Pass    a    (connect,    read)    timeout    tuple,    or    a    single    float    to    set    both    timeouts    to    the    same    value'.format(timeout)
            raise ValueError(err)
    else:
        timeout = TimeoutSauce(connect=timeout, read=timeout)
    try:
        if (not chunked):
            resp = conn.urlopen(method=request.method, url=url, body=request.body, headers=request.headers, redirect=False, assert_same_host=False, preload_content=False, decode_content=False, retries=self.max_retries, timeout=timeout)
        else:
            if hasattr(conn, 'proxy_pool'):
                conn = conn.proxy_pool
            low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)
            try:
                low_conn.putrequest(request.method, url, skip_accept_encoding=True)
                for (header, value) in request.headers.items():
                    low_conn.putheader(header, value)
                low_conn.endheaders()
                for i in request.body:
                    low_conn.send(hex(len(i))[2:].encode('utf-8'))
                    low_conn.send('\r\n')
                    low_conn.send(i)
                    low_conn.send('\r\n')
                low_conn.send('0\r\n\r\n')
                try:
                    r = low_conn.getresponse(buffering=True)
                except TypeError:
                    r = low_conn.getresponse()
                resp = HTTPResponse.from_httplib(r, pool=conn, connection=low_conn, preload_content=False, decode_content=False)
            except:
                low_conn.close()
                raise
    except (ProtocolError, socket.error) as err:
        raise ConnectionError(err, request=request)
    except MaxRetryError as e:
        if isinstance(e.reason, ConnectTimeoutError):
            if (not isinstance(e.reason, NewConnectionError)):
                raise ConnectTimeout(e, request=request)
        if isinstance(e.reason, ResponseError):
            raise RetryError(e, request=request)
        raise ConnectionError(e, request=request)
    except ClosedPoolError as e:
        raise ConnectionError(e, request=request)
    except _ProxyError as e:
        raise ProxyError(e)
    except (_SSLError, _HTTPError) as e:
        if isinstance(e, _SSLError):
            raise SSLError(e, request=request)
        elif isinstance(e, ReadTimeoutError):
            raise ReadTimeout(e, request=request)
        else:
            raise
    return self.build_response(request, resp)
