How to use the requests3.cookies.extract_cookies_to_jar function in requests3

"""
        response = Response()
        # Fallback to None if there's no status_code, for whatever reason.
        response.status_code = getattr(resp, 'status', None)
        # Make headers case-insensitive.
        response.headers = HTTPHeaderDict(getattr(resp, 'headers', {}))
        # Set encoding.
        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = resp
        response.reason = response.raw.reason
        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url
        # Add new cookies from the server.
        extract_cookies_to_jar(response.cookies, req, resp)
        # Give the Response some context.
        response.request = req
        response.connection = self
        return response

# Get the appropriate adapter to use
        adapter = self.get_adapter(url=request.url)
        # Start time (approximately) of the request
        start = preferred_clock()
        # Send the request
        r = adapter.send(request, **kwargs)
        # Total elapsed time of the request (approximately)
        elapsed = preferred_clock() - start
        r.elapsed = timedelta(seconds=elapsed)
        # Response manipulation hooks.
        r = dispatch_hook('response', hooks, r, **kwargs)
        # Persist cookies
        if r.history:
            # If the hooks create history then we want those cookies too
            for resp in r.history:
                extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
        extract_cookies_to_jar(self.cookies, request, r.raw)
        # Redirect resolving generator.
        gen = self.resolve_redirects(r, request, **kwargs)
        # Resolve redirects, if allowed.
        history = [resp for resp in gen] if allow_redirects else []
        # If there is a history, replace ``r`` with the last response
        if history:
            r = history.pop()
        # If redirects aren't being followed, store the response on the Request for Response.next().
        if not allow_redirects:
            try:
                r._next = next(
                    self.resolve_redirects(
                        r, request, yield_requests=True, **kwargs
                    )
                )

adapter = self.get_adapter(url=request.url)
        # Start time (approximately) of the request
        start = preferred_clock()
        # Send the request
        r = adapter.send(request, **kwargs)
        # Total elapsed time of the request (approximately)
        elapsed = preferred_clock() - start
        r.elapsed = timedelta(seconds=elapsed)
        # Response manipulation hooks.
        r = dispatch_hook('response', hooks, r, **kwargs)
        # Persist cookies
        if r.history:
            # If the hooks create history then we want those cookies too
            for resp in r.history:
                extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
        extract_cookies_to_jar(self.cookies, request, r.raw)
        # Redirect resolving generator.
        gen = self.resolve_redirects(r, request, **kwargs)
        # Resolve redirects, if allowed.
        history = [resp for resp in gen] if allow_redirects else []
        # If there is a history, replace ``r`` with the last response
        if history:
            r = history.pop()
        # If redirects aren't being followed, store the response on the Request for Response.next().
        if not allow_redirects:
            try:
                r._next = next(
                    self.resolve_redirects(
                        r, request, yield_requests=True, **kwargs
                    )
                )
            except StopIteration:

# https://github.com/requests/requests/issues/3490
                purged_headers = (
                    'Content-Length', 'Content-Type', 'Transfer-Encoding'
                )
                for header in purged_headers:
                    prepared_request.headers.pop(header, None)
                prepared_request.body = None
            headers = prepared_request.headers
            try:
                del headers['Cookie']
            except KeyError:
                pass
            # Extract any cookies sent on the response to the cookiejar
            # in the new request. Because we've mutated our copied prepared
            # request, use the old one that we haven't yet touched.
            extract_cookies_to_jar(
                prepared_request._cookies, request, response.raw
            )
            merge_cookies(prepared_request._cookies, self.cookies)
            prepared_request.prepare_cookies(prepared_request._cookies)
            # Rebuild auth and proxy information.
            proxies = self.rebuild_proxies(prepared_request, proxies)
            self.rebuild_auth(prepared_request, response)
            # A failed tell() sets `_body_position` to `object()`. This non-None
            # value ensures `rewindable` will be True, allowing us to raise an
            # UnrewindableBodyError, instead of hanging the connection.
            rewindable = (
                prepared_request._body_position is not None and
                ('Content-Length' in headers or 'Transfer-Encoding' in headers)
            )
            # Attempt to rewind consumed file-like object.
            if rewindable:

"""
        response = AsyncResponse()
        # Fallback to None if there's no status_code, for whatever reason.
        response.status_code = getattr(resp, 'status', None)
        # Make headers case-insensitive.
        response.headers = HTTPHeaderDict(getattr(resp, 'headers', {}))
        # Set encoding.
        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = resp
        response.reason = response.raw.reason
        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url
        # Add new cookies from the server.
        extract_cookies_to_jar(response.cookies, req, resp)
        # Give the Response some context.
        response.request = req
        response.connection = self
        return response

# Get the appropriate adapter to use
        adapter = self.get_adapter(url=request.url)
        # Start time (approximately) of the request
        start = preferred_clock()
        # Send the request
        r = await adapter.send(request, **kwargs)
        # Total elapsed time of the request (approximately)
        elapsed = preferred_clock() - start
        r.elapsed = timedelta(seconds=elapsed)
        # Response manipulation hooks.
        r = dispatch_hook('response', hooks, r, **kwargs)
        # Persist cookies
        if r.history:
            # If the hooks create history then we want those cookies too
            for resp in r.history:
                extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
        extract_cookies_to_jar(self.cookies, request, r.raw)
        # Redirect resolving generator.
        gen = self.resolve_redirects(r, request, **kwargs)
        # Resolve redirects, if allowed.
        history = [resp for resp in gen] if allow_redirects else []
        # If there is a history, replace ``r`` with the last response
        if history:
            r = history.pop()
        # If redirects aren't being followed, store the response on the Request for Response.next().
        if not allow_redirects:
            try:
                r._next = next(
                    self.resolve_redirects(
                        r, request, yield_requests=True, **kwargs
                    )
                )

else:
                response = self.send(
                    request,
                    stream=stream,
                    timeout=timeout,
                    verify=verify,
                    cert=cert,
                    proxies=proxies,
                    allow_redirects=False,
                    **adapter_kwargs,
                )
                # copy our history tracker into the response
                response.history = history[:]
                # append the new response to the history tracker for the next iteration
                history.append(response)
                extract_cookies_to_jar(
                    self.cookies, prepared_request, response.raw
                )
                # extract redirect url, if any, for the next loop
                location_url = self.get_redirect_target(response)
                yield response

adapter = self.get_adapter(url=request.url)
        # Start time (approximately) of the request
        start = preferred_clock()
        # Send the request
        r = await adapter.send(request, **kwargs)
        # Total elapsed time of the request (approximately)
        elapsed = preferred_clock() - start
        r.elapsed = timedelta(seconds=elapsed)
        # Response manipulation hooks.
        r = dispatch_hook('response', hooks, r, **kwargs)
        # Persist cookies
        if r.history:
            # If the hooks create history then we want those cookies too
            for resp in r.history:
                extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
        extract_cookies_to_jar(self.cookies, request, r.raw)
        # Redirect resolving generator.
        gen = self.resolve_redirects(r, request, **kwargs)
        # Resolve redirects, if allowed.
        history = [resp for resp in gen] if allow_redirects else []
        # If there is a history, replace ``r`` with the last response
        if history:
            r = history.pop()
        # If redirects aren't being followed, store the response on the Request for Response.next().
        if not allow_redirects:
            try:
                r._next = next(
                    self.resolve_redirects(
                        r, request, yield_requests=True, **kwargs
                    )
                )
            except StopIteration: