docs: def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
          """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 (`connect timeout, read
              timeout <user/advanced.html#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.
          """
  
          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:
                  # this may raise a string formatting error.
                  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=Retry(self.max_retries, read=False),
                      timeout=timeout
                  )
  
              # Send the request.
              else:
                  if hasattr(conn, 'proxy_pool'):
                      conn = conn.proxy_pool
  
                  low_conn = conn._get_conn(timeout=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(b'\r\n')
                          low_conn.send(i)
                          low_conn.send(b'\r\n')
                      low_conn.send(b'0\r\n\r\n')
  
                      r = low_conn.getresponse()
                      resp = HTTPResponse.from_httplib(
                          r,
                          pool=conn,
                          connection=low_conn,
                          preload_content=False,
                          decode_content=False
                      )
                  except:
                      # If we hit any problems here, clean up the connection.
                      # Then, reraise so that we can handle the actual exception.
                      low_conn.close()
                      raise
                  else:
                      # All is well, return the connection to the pool.
                      conn._put_conn(low_conn)
  
          except (ProtocolError, socket.error) as err:
              raise ConnectionError(err, request=request)
  
          except MaxRetryError as e:
              if isinstance(e.reason, ConnectTimeoutError):
                  raise ConnectTimeout(e, request=request)
  
              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)