async def request(self, method, url=None, *, path='', retries=1,
                      connection_timeout=60, **kwargs):
        '''
        This is the template for all of the `http method` methods for
        the Session.

        Args:
            method (str): A http method, such as 'GET' or 'POST'.
            url (str): The url the request should be made to.
            path (str): An optional kw-arg for use in Session method calls,
                for specifying a particular path. Usually to be used in
                conjunction with the base_location/endpoint paradigm.
            kwargs: Any number of the following:
                        data (dict or str): Info to be processed as a
                            body-bound query.
                        params (dict or str): Info to be processed as a
                            url-bound query.
                        headers (dict): User HTTP headers to be used in the
                            request.
                        encoding (str): The str representation of the codec to
                            process the request under.
                        json (dict): A dict to be formatted as json and sent in
                            the request body.
                        files (dict): A dict of `filename:filepath`s to be sent
                            as multipart.
                        cookies (dict): A dict of `name:value` cookies to be
                            passed in request.
                        callback (func): A callback function to be called on
                            each bytechunk of of the response body.
                        timeout (int or float): A numeric representation of the
                            longest time to wait on a complete response once a
                            request has been sent.
                        retries (int): The number of attempts to try against
                            connection errors.
                        max_redirects (int): The maximum number of redirects
                            allowed.
                        persist_cookies (True or None): Passing True
                            instantiates a CookieTracker object to manage the
                            return of cookies to the server under the relevant
                            domains.
                        auth (child of AuthBase): An object for handling auth
                            construction.

        When you call something like Session.get() or asks.post(), you're
        really calling a partial method that has the 'method' argument
        pre-completed.
        '''
        timeout = kwargs.get('timeout', None)
        req_headers = kwargs.pop('headers', None)

        if self.headers is not None:
            headers = copy(self.headers)
        if req_headers is not None:
            headers.update(req_headers)
        req_headers = headers

        async with self.sema:
            if url is None:
                url = self._make_url() + path

            retry = False

            sock = None
            try:
                sock = await timeout_manager(
                    connection_timeout, self._grab_connection, url)
                port = sock.port

                req_obj = RequestProcessor(
                    self,
                    method,
                    url,
                    port,
                    headers=req_headers,
                    encoding=self.encoding,
                    sock=sock,
                    persist_cookies=self._cookie_tracker,
                    **kwargs
                )

                try:
                    if timeout is None:
                        sock, r = await req_obj.make_request()
                    else:
                        sock, r = await timeout_manager(timeout, req_obj.make_request)
                except BadHttpResponse:
                    if timeout is None:
                        sock, r = await req_obj.make_request()
                    else:
                        sock, r = await timeout_manager(timeout, req_obj.make_request)

                if sock is not None:
                    try:
                        if r.headers['connection'].lower() == 'close':
                            sock._active = False
                            await sock.close()
                    except KeyError:
                        pass
                    await self.return_to_pool(sock)

            # ConnectionErrors are special. They are the only kind of exception
            # we ever want to suppress. All other exceptions are re-raised or
            # raised through another exception.
            except ConnectionError as e:
                if retries > 0:
                    retry = True
                    retries -= 1
                else:
                    raise e

            except Exception as e:
                if sock:
                    await self._handle_exception(e, sock)
                raise

            # any BaseException is considered unlawful murder, and
            # Session.cleanup should be called to tidy up sockets.
            except BaseException as e:
                if sock:
                    await sock.close()
                raise e

        if retry:
            return (await self.request(method,
                                       url,
                                       path=path,
                                       retries=retries,
                                       headers=headers,
                                       **kwargs))

        return r
This is the template for all of the `http method` methods for
        the Session.

        Args:
            method (str): A http method, such as 'GET' or 'POST'.
            url (str): The url the request should be made to.
            path (str): An optional kw-arg for use in Session method calls,
                for specifying a particular path. Usually to be used in
                conjunction with the base_location/endpoint paradigm.
            kwargs: Any number of the following:
                        data (dict or str): Info to be processed as a
                            body-bound query.
                        params (dict or str): Info to be processed as a
                            url-bound query.
                        headers (dict): User HTTP headers to be used in the
                            request.
                        encoding (str): The str representation of the codec to
                            process the request under.
                        json (dict): A dict to be formatted as json and sent in
                            the request body.
                        files (dict): A dict of `filename:filepath`s to be sent
                            as multipart.
                        cookies (dict): A dict of `name:value` cookies to be
                            passed in request.
                        callback (func): A callback function to be called on
                            each bytechunk of of the response body.
                        timeout (int or float): A numeric representation of the
                            longest time to wait on a complete response once a
                            request has been sent.
                        retries (int): The number of attempts to try against
                            connection errors.
                        max_redirects (int): The maximum number of redirects
                            allowed.
                        persist_cookies (True or None): Passing True
                            instantiates a CookieTracker object to manage the
                            return of cookies to the server under the relevant
                            domains.
                        auth (child of AuthBase): An object for handling auth
                            construction.

        When you call something like Session.get() or asks.post(), you're
        really calling a partial method that has the 'method' argument
        pre-completed.