'Sends the request. Returns True if successful, False if not.
If there was an HTTPError during transmission,
self.response.status_code will contain the HTTPError code.
Once a request is successfully sent, `sent` will equal True.
:param anyway: If True, request will be sent, even if it has
already been sent.
:param prefetch: If not None, will override the request\'s own setting
for prefetch.'

def send(self, anyway=False, prefetch=None):

    url = self.full_url
    r = dispatch_hook('pre_request', self.hooks, self)
    self.__dict__.update(r.__dict__)
    if self.config.get('verbose'):
        self.config.get('verbose').write(('%s            %s            %s\n' % (datetime.now().isoformat(), self.method, url)))
    if ((not self.auth) and self.config.get('trust_env')):
        self.auth = get_netrc_auth(url)
    if self.auth:
        if (isinstance(self.auth, tuple) and (len(self.auth) == 2)):
            self.auth = HTTPBasicAuth(*self.auth)
        r = self.auth(self)
        self.__dict__.update(r.__dict__)
    body = None
    content_type = None
    if self.files:
        (body, content_type) = self._encode_files(self.files)
    elif self.data:
        body = self._encode_params(self.data)
        if (isinstance(self.data, str) or isinstance(self.data, builtin_str) or hasattr(self.data, 'read')):
            content_type = None
        else:
            content_type = 'application/x-www-form-urlencoded'
    if (content_type and (not ('content-type' in self.headers))):
        self.headers['Content-Type'] = content_type
    _p = urlparse(url)
    no_proxy = filter((lambda x: x.strip()), self.proxies.get('no', '').split(','))
    proxy = self.proxies.get(_p.scheme)
    if (proxy and (not any(map(_p.hostname.endswith, no_proxy)))):
        conn = poolmanager.proxy_from_url(proxy)
        _proxy = urlparse(proxy)
        if ('@' in _proxy.netloc):
            (auth, url) = _proxy.netloc.split('@', 1)
            self.proxy_auth = HTTPProxyAuth(*auth.split(':', 1))
            r = self.proxy_auth(self)
            self.__dict__.update(r.__dict__)
    else:
        try:
            if self.config.get('keep_alive'):
                conn = self._poolmanager.connection_from_url(url)
            else:
                conn = connectionpool.connection_from_url(url)
                self.headers['Connection'] = 'close'
        except LocationParseError as e:
            raise InvalidURL(e)
    if (url.startswith('https') and self.verify):
        cert_loc = None
        if (self.verify is not True):
            cert_loc = self.verify
        if ((not cert_loc) and self.config.get('trust_env')):
            cert_loc = os.environ.get('REQUESTS_CA_BUNDLE')
        if ((not cert_loc) and self.config.get('trust_env')):
            cert_loc = os.environ.get('CURL_CA_BUNDLE')
        if (not cert_loc):
            cert_loc = DEFAULT_CA_BUNDLE_PATH
        if (not cert_loc):
            raise Exception('Could    not    find    a    suitable    SSL    CA    certificate    bundle.')
        conn.cert_reqs = 'CERT_REQUIRED'
        conn.ca_certs = cert_loc
    else:
        conn.cert_reqs = 'CERT_NONE'
        conn.ca_certs = None
    if self.cert:
        if (len(self.cert) == 2):
            conn.cert_file = self.cert[0]
            conn.key_file = self.cert[1]
        else:
            conn.cert_file = self.cert
    if ((not self.sent) or anyway):
        if ('cookie' not in self.headers):
            cookie_header = get_cookie_header(self.cookies, self)
            if (cookie_header is not None):
                self.headers['Cookie'] = cookie_header
        r = dispatch_hook('pre_send', self.hooks, self)
        self.__dict__.update(r.__dict__)
        try:
            r = conn.urlopen(method=self.method, url=self.path_url, body=body, headers=self.headers, redirect=False, assert_same_host=False, preload_content=False, decode_content=False, retries=self.config.get('max_retries', 0), timeout=self.timeout)
            self.sent = True
        except socket.error as sockerr:
            raise ConnectionError(sockerr)
        except MaxRetryError as e:
            raise ConnectionError(e)
        except (_SSLError, _HTTPError) as e:
            if isinstance(e, _SSLError):
                raise SSLError(e)
            elif isinstance(e, TimeoutError):
                raise Timeout(e)
            else:
                raise Timeout('Request    timed    out.')
        self._build_response(r)
        self.response = dispatch_hook('response', self.hooks, self.response)
        r = dispatch_hook('post_request', self.hooks, self)
        self.__dict__.update(r.__dict__)
        if (prefetch is None):
            prefetch = self.prefetch
        if prefetch:
            self.response.content
        if self.config.get('danger_mode'):
            self.response.raise_for_status()
        return self.sent
