@scrypted/arlo 0.11.25 → 0.11.26

package/venv/lib/python3.10/site-packages/curl_cffi/requests/session.py

@@ -0,0 +1,1021 @@
+from __future__ import annotations
+
+import sys
+import asyncio
+import queue
+import threading
+import warnings
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager, contextmanager, suppress
+from io import BytesIO
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+    Generic,
+    TypeVar
+)
+from urllib.parse import urlparse
+
+from ..aio import AsyncCurl
+from ..const import CurlHttpVersion, CurlInfo, CurlOpt
+from ..curl import Curl, CurlError, CurlMime
+from ..utils import CurlCffiWarning
+from .cookies import Cookies, CookieTypes, CurlMorsel
+from .exceptions import RequestException, SessionClosed, code2error
+from .headers import Headers, HeaderTypes
+from .impersonate import BrowserTypeLiteral, ExtraFingerprints, ExtraFpDict
+from .models import Response
+from .utils import not_set, set_curl_options
+from .websockets import AsyncWebSocket, WebSocket
+
+with suppress(ImportError):
+    import gevent
+
+with suppress(ImportError):
+    import eventlet.tpool
+
+# Added in 3.13: https://docs.python.org/3/library/typing.html#typing.TypeVar.__default__
+if sys.version_info >= (3, 13):
+    R = TypeVar('R', bound=Response, default=Response)
+else:
+    R = TypeVar('R', bound=Response)
+
+if TYPE_CHECKING:
+    from typing_extensions import Unpack
+
+    class ProxySpec(TypedDict, total=False):
+        all: str
+        http: str
+        https: str
+        ws: str
+        wss: str
+
+    class BaseSessionParams(Generic[R], TypedDict, total=False):
+        headers: Optional[HeaderTypes]
+        cookies: Optional[CookieTypes]
+        auth: Optional[Tuple[str, str]]
+        proxies: Optional[ProxySpec]
+        proxy: Optional[str]
+        proxy_auth: Optional[Tuple[str, str]]
+        base_url: Optional[str]
+        params: Optional[dict]
+        verify: bool
+        timeout: Union[float, Tuple[float, float]]
+        trust_env: bool
+        allow_redirects: bool
+        max_redirects: int
+        impersonate: Optional[BrowserTypeLiteral]
+        ja3: Optional[str]
+        akamai: Optional[str]
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]]
+        default_headers: bool
+        default_encoding: Union[str, Callable[[bytes], str]]
+        curl_options: Optional[dict]
+        curl_infos: Optional[list]
+        http_version: Optional[CurlHttpVersion]
+        debug: bool
+        interface: Optional[str]
+        cert: Optional[Union[str, Tuple[str, str]]]
+        response_class: Optional[Type[R]]
+
+    class StreamRequestParams(TypedDict, total=False):
+        params: Optional[Union[Dict, List, Tuple]]
+        data: Optional[Union[Dict[str, str], List[Tuple], str, BytesIO, bytes]]
+        json: Optional[dict]
+        headers: Optional[HeaderTypes]
+        cookies: Optional[CookieTypes]
+        files: Optional[Dict]
+        auth: Optional[Tuple[str, str]]
+        timeout: Optional[Union[float, Tuple[float, float], object]]
+        allow_redirects: Optional[bool]
+        max_redirects: Optional[int]
+        proxies: Optional[ProxySpec]
+        proxy: Optional[str]
+        proxy_auth: Optional[Tuple[str, str]]
+        verify: Optional[bool]
+        referer: Optional[str]
+        accept_encoding: Optional[str]
+        content_callback: Optional[Callable]
+        impersonate: Optional[BrowserTypeLiteral]
+        ja3: Optional[str]
+        akamai: Optional[str]
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]]
+        default_headers: Optional[bool]
+        default_encoding: Union[str, Callable[[bytes], str]]
+        quote: Union[str, Literal[False]]
+        http_version: Optional[CurlHttpVersion]
+        interface: Optional[str]
+        cert: Optional[Union[str, Tuple[str, str]]]
+        max_recv_speed: int
+        multipart: Optional[CurlMime]
+
+    class RequestParams(StreamRequestParams, total=False):
+        stream: Optional[bool]
+
+else:
+    class _Unpack:
+        @staticmethod
+        def __getitem__(*args, **kwargs): pass
+    Unpack = _Unpack()
+
+    ProxySpec = Dict[str, str]
+    BaseSessionParams = TypedDict
+    StreamRequestParams, RequestParams = TypedDict, TypedDict
+
+ThreadType = Literal["eventlet", "gevent"]
+HttpMethod = Literal["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "TRACE", "PATCH", "QUERY"]
+
+
+def _is_absolute_url(url: str) -> bool:
+    """Check if the provided url is an absolute url"""
+    parsed_url = urlparse(url)
+    return bool(parsed_url.scheme and parsed_url.hostname)
+
+
+def _peek_queue(q: queue.Queue, default=None):
+    try:
+        return q.queue[0]
+    except IndexError:
+        return default
+
+
+def _peek_aio_queue(q: asyncio.Queue, default=None):
+    try:
+        return q._queue[0]  # type: ignore
+    except IndexError:
+        return default
+
+
+class BaseSession(Generic[R]):
+    """Provide common methods for setting curl options and reading info in sessions."""
+
+    def __init__(
+        self,
+        *,
+        headers: Optional[HeaderTypes] = None,
+        cookies: Optional[CookieTypes] = None,
+        auth: Optional[Tuple[str, str]] = None,
+        proxies: Optional[ProxySpec] = None,
+        proxy: Optional[str] = None,
+        proxy_auth: Optional[Tuple[str, str]] = None,
+        base_url: Optional[str] = None,
+        params: Optional[dict] = None,
+        verify: bool = True,
+        timeout: Union[float, Tuple[float, float]] = 30,
+        trust_env: bool = True,
+        allow_redirects: bool = True,
+        max_redirects: int = 30,
+        impersonate: Optional[BrowserTypeLiteral] = None,
+        ja3: Optional[str] = None,
+        akamai: Optional[str] = None,
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]] = None,
+        default_headers: bool = True,
+        default_encoding: Union[str, Callable[[bytes], str]] = "utf-8",
+        curl_options: Optional[dict] = None,
+        curl_infos: Optional[list] = None,
+        http_version: Optional[CurlHttpVersion] = None,
+        debug: bool = False,
+        interface: Optional[str] = None,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        response_class: Optional[Type[R]] = None,
+    ):
+        self.headers = Headers(headers)
+        self._cookies = Cookies(cookies)  # guarded by @property
+        self.auth = auth
+        self.base_url = base_url
+        self.params = params
+        self.verify = verify
+        self.timeout = timeout
+        self.trust_env = trust_env
+        self.allow_redirects = allow_redirects
+        self.max_redirects = max_redirects
+        self.impersonate = impersonate
+        self.ja3 = ja3
+        self.akamai = akamai
+        self.extra_fp = extra_fp
+        self.default_headers = default_headers
+        self.default_encoding = default_encoding
+        self.curl_options = curl_options or {}
+        self.curl_infos = curl_infos or []
+        self.http_version = http_version
+        self.debug = debug
+        self.interface = interface
+        self.cert = cert
+
+        if response_class is not None and issubclass(response_class, Response) is False:
+            raise TypeError(
+                "`response_class` must be a subclass of `curl_cffi.requests.models.Response`"
+                f" not of type `{response_class}`"
+            )
+        self.response_class = response_class or Response
+
+        if proxy and proxies:
+            raise TypeError("Cannot specify both 'proxy' and 'proxies'")
+        if proxy:
+            proxies = {"all": proxy}
+        self.proxies: ProxySpec = proxies or {}
+        self.proxy_auth = proxy_auth
+
+        if self.base_url and not _is_absolute_url(self.base_url):
+            raise ValueError("You need to provide an absolute url for 'base_url'")
+
+        self._closed = False
+
+    def _parse_response(self, curl, buffer, header_buffer, default_encoding) -> R:
+        c = curl
+        rsp = cast(R, self.response_class(c))
+        rsp.url = cast(bytes, c.getinfo(CurlInfo.EFFECTIVE_URL)).decode()
+        if buffer:
+            rsp.content = buffer.getvalue()
+        rsp.http_version = cast(int, c.getinfo(CurlInfo.HTTP_VERSION))
+        rsp.status_code = cast(int, c.getinfo(CurlInfo.RESPONSE_CODE))
+        rsp.ok = 200 <= rsp.status_code < 400
+        header_lines = header_buffer.getvalue().splitlines()
+
+        # TODO: history urls
+        header_list: List[bytes] = []
+        for header_line in header_lines:
+            if not header_line.strip():
+                continue
+            if header_line.startswith(b"HTTP/"):
+                # read header from last response
+                rsp.reason = c.get_reason_phrase(header_line).decode()
+                # empty header list for new redirected response
+                header_list = []
+                continue
+            if header_line.startswith(b" ") or header_line.startswith(b"\t"):
+                header_list[-1] += header_line
+                continue
+            header_list.append(header_line)
+        rsp.headers = Headers(header_list)
+
+        # cookies
+        morsels = [CurlMorsel.from_curl_format(c) for c in c.getinfo(CurlInfo.COOKIELIST)]
+        # for l in c.getinfo(CurlInfo.COOKIELIST):
+        #     print("Curl Cookies", l.decode())
+        self._cookies.update_cookies_from_curl(morsels)
+        rsp.cookies = self._cookies
+        # print("Cookies after extraction", self._cookies)
+
+        rsp.primary_ip = cast(bytes, c.getinfo(CurlInfo.PRIMARY_IP)).decode()
+        rsp.local_ip = cast(bytes, c.getinfo(CurlInfo.LOCAL_IP)).decode()
+        rsp.default_encoding = default_encoding
+        rsp.elapsed = cast(float, c.getinfo(CurlInfo.TOTAL_TIME))
+        rsp.redirect_count = cast(int, c.getinfo(CurlInfo.REDIRECT_COUNT))
+        rsp.redirect_url = cast(bytes, c.getinfo(CurlInfo.REDIRECT_URL)).decode()
+
+        # custom info options
+        for info in self.curl_infos:
+            rsp.infos[info] = c.getinfo(info)
+
+        return rsp
+
+    def _check_session_closed(self):
+        if self._closed:
+            raise SessionClosed("Session is closed, cannot send request.")
+
+    @property
+    def cookies(self) -> Cookies:
+        return self._cookies
+
+    @cookies.setter
+    def cookies(self, cookies: CookieTypes) -> None:
+        # This ensures that the cookies property is always converted to Cookies.
+        self._cookies = Cookies(cookies)
+
+class Session(BaseSession[R]):
+    """A request session, cookies and connections will be reused. This object is thread-safe,
+    but it's recommended to use a separate session for each thread."""
+
+    def __init__(
+        self,
+        curl: Optional[Curl] = None,
+        thread: Optional[ThreadType] = None,
+        use_thread_local_curl: bool = True,
+        **kwargs: Unpack[BaseSessionParams[R]],
+    ):
+        """
+        Parameters set in the init method will be overriden by the same parameter in request method.
+
+        Args:
+            curl: curl object to use in the session. If not provided, a new one will be
+                created. Also, a fresh curl object will always be created when accessed
+                from another thread.
+            thread: thread engine to use for working with other thread implementations.
+                choices: eventlet, gevent.
+            headers: headers to use in the session.
+            cookies: cookies to add in the session.
+            auth: HTTP basic auth, a tuple of (username, password), only basic auth is supported.
+            proxies: dict of proxies to use, format: {"http": proxy_url, "https": proxy_url}.
+            proxy: proxy to use, format: "http://proxy_url".
+                Cannot be used with the above parameter.
+            proxy_auth: HTTP basic auth for proxy, a tuple of (username, password).
+            base_url: absolute url to use as base for relative urls.
+            params: query string for the session.
+            verify: whether to verify https certs.
+            timeout: how many seconds to wait before giving up.
+            trust_env: use http_proxy/https_proxy and other environments, default True.
+            allow_redirects: whether to allow redirection.
+            max_redirects: max redirect counts, default 30, use -1 for unlimited.
+            impersonate: which browser version to impersonate in the session.
+            ja3: ja3 string to impersonate in the session.
+            akamai: akamai string to impersonate in the session.
+            extra_fp: extra fingerprints options, in complement to ja3 and akamai strings.
+            interface: which interface use.
+            default_encoding: encoding for decoding response content if charset is not found in
+                headers. Defaults to "utf-8". Can be set to a callable for automatic detection.
+            cert: a tuple of (cert, key) filenames for client cert.
+            response_class: A customized subtype of ``Response`` to use.
+
+        Notes:
+            This class can be used as a context manager.
+
+        .. code-block:: python
+
+            from curl_cffi.requests import Session
+
+            with Session() as s:
+                r = s.get("https://example.com")
+        """
+        super().__init__(**kwargs)
+        self._thread = thread
+        self._use_thread_local_curl = use_thread_local_curl
+        self._queue = None
+        self._executor = None
+        if use_thread_local_curl:
+            self._local = threading.local()
+            if curl:
+                self._is_customized_curl = True
+                self._local.curl = curl
+            else:
+                self._is_customized_curl = False
+                self._local.curl = Curl(debug=self.debug)
+        else:
+            self._curl = curl if curl else Curl(debug=self.debug)
+
+    @property
+    def curl(self):
+        if self._use_thread_local_curl:
+            if self._is_customized_curl:
+                warnings.warn(
+                    "Creating fresh curl handle in different thread.", CurlCffiWarning, stacklevel=2
+                )
+            if not getattr(self._local, "curl", None):
+                self._local.curl = Curl(debug=self.debug)
+            return self._local.curl
+        else:
+            return self._curl
+
+    @property
+    def executor(self):
+        if self._executor is None:
+            self._executor = ThreadPoolExecutor()
+        return self._executor
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self) -> None:
+        """Close the session."""
+        self._closed = True
+        self.curl.close()
+
+    @contextmanager
+    def stream(
+        self, 
+        method: HttpMethod,
+        url: str,
+        **kwargs: Unpack[StreamRequestParams],
+    ):
+        """Equivalent to ``with request(..., stream=True) as r:``"""
+        rsp = self.request(method=method, url=url, **kwargs, stream=True)
+        try:
+            yield rsp
+        finally:
+            rsp.close()
+
+    def ws_connect(
+        self, url, on_message=None, on_error=None, on_open=None, on_close=None, **kwargs
+    ) -> WebSocket:
+        """Connects to a websocket url.
+
+        Note: This method is deprecated, use WebSocket instead.
+
+        Args:
+            url: the ws url to connect.
+            on_message: message callback, ``def on_message(ws, str)``
+            on_error: error callback, ``def on_error(ws, error)``
+            on_open: open callback, ``def on_open(ws)``
+            on_close: close callback, ``def on_close(ws)``
+
+        Other parameters are the same as ``.request``
+
+        Returns:
+            a WebSocket instance to communicate with the server.
+        """
+        self._check_session_closed()
+
+        curl = self.curl.duphandle()
+        self.curl.reset()
+
+        ws = WebSocket(
+            curl=curl,
+            on_message=on_message,
+            on_error=on_error,
+            on_open=on_open,
+            on_close=on_close,
+        )
+
+        ws.connect(url, **kwargs)
+        return ws
+
+    def request(
+        self,
+        method: HttpMethod,
+        url: str,
+        params: Optional[Union[Dict, List, Tuple]] = None,
+        data: Optional[Union[Dict[str, str], List[Tuple], str, BytesIO, bytes]] = None,
+        json: Optional[dict] = None,
+        headers: Optional[HeaderTypes] = None,
+        cookies: Optional[CookieTypes] = None,
+        files: Optional[Dict] = None,
+        auth: Optional[Tuple[str, str]] = None,
+        timeout: Optional[Union[float, Tuple[float, float], object]] = not_set,
+        allow_redirects: Optional[bool] = None,
+        max_redirects: Optional[int] = None,
+        proxies: Optional[ProxySpec] = None,
+        proxy: Optional[str] = None,
+        proxy_auth: Optional[Tuple[str, str]] = None,
+        verify: Optional[bool] = None,
+        referer: Optional[str] = None,
+        accept_encoding: Optional[str] = "gzip, deflate, br",
+        content_callback: Optional[Callable] = None,
+        impersonate: Optional[BrowserTypeLiteral] = None,
+        ja3: Optional[str] = None,
+        akamai: Optional[str] = None,
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]] = None,
+        default_headers: Optional[bool] = None,
+        default_encoding: Union[str, Callable[[bytes], str]] = "utf-8",
+        quote: Union[str, Literal[False]] = "",
+        http_version: Optional[CurlHttpVersion] = None,
+        interface: Optional[str] = None,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        stream: Optional[bool] = None,
+        max_recv_speed: int = 0,
+        multipart: Optional[CurlMime] = None,
+    ):
+        """Send the request, see ``requests.request`` for details on parameters."""
+
+        self._check_session_closed()
+
+        # clone a new curl instance for streaming response
+        if stream:
+            c = self.curl.duphandle()
+            self.curl.reset()
+        else:
+            c = self.curl
+
+        req, buffer, header_buffer, q, header_recved, quit_now = set_curl_options(
+            c,
+            method=method,
+            url=url,
+            params_list=[self.params, params],
+            base_url=self.base_url,
+            data=data,
+            json=json,
+            headers_list=[self.headers, headers],
+            cookies_list=[self._cookies, cookies],
+            files=files,
+            auth=auth or self.auth,
+            timeout=self.timeout if timeout is not_set else timeout,
+            allow_redirects=self.allow_redirects if allow_redirects is None else allow_redirects,
+            max_redirects=self.max_redirects if max_redirects is None else max_redirects,
+            proxies_list=[self.proxies, proxies],
+            proxy=proxy,
+            proxy_auth=proxy_auth or self.proxy_auth,
+            verify_list=[self.verify, verify],
+            referer=referer,
+            accept_encoding=accept_encoding,
+            content_callback=content_callback,
+            impersonate=impersonate or self.impersonate,
+            ja3=ja3 or self.ja3,
+            akamai=akamai or self.akamai,
+            extra_fp=extra_fp or self.extra_fp,
+            default_headers=self.default_headers if default_headers is None else default_headers,
+            quote=quote,
+            http_version=http_version or self.http_version,
+            interface=interface or self.interface,
+            stream=stream,
+            max_recv_speed=max_recv_speed,
+            multipart=multipart,
+            cert=cert or self.cert,
+            curl_options=self.curl_options,
+            queue_class=queue.Queue,
+            event_class=threading.Event,
+        )
+
+        if stream:
+            header_parsed = threading.Event()
+
+            def perform():
+                try:
+                    c.perform()
+                except CurlError as e:
+                    rsp = self._parse_response(c, buffer, header_buffer, default_encoding)
+                    rsp.request = req
+                    cast(queue.Queue, q).put_nowait(RequestException(str(e), e.code, rsp))
+                finally:
+                    if not cast(threading.Event, header_recved).is_set():
+                        cast(threading.Event, header_recved).set()
+                    # None acts as a sentinel
+                    cast(queue.Queue, q).put(None)
+
+            def cleanup(fut):
+                header_parsed.wait()
+                c.reset()
+
+            stream_task = self.executor.submit(perform)
+            stream_task.add_done_callback(cleanup)
+
+            # Wait for the first chunk
+            cast(threading.Event, header_recved).wait()
+            rsp = self._parse_response(c, buffer, header_buffer, default_encoding)
+            header_parsed.set()
+
+            # Raise the exception if something wrong happens when receiving the header.
+            first_element = _peek_queue(cast(queue.Queue, q))
+            if isinstance(first_element, RequestException):
+                c.reset()
+                raise first_element
+
+            rsp.request = req
+            rsp.stream_task = stream_task
+            rsp.quit_now = quit_now
+            rsp.queue = q
+            return rsp
+        else:
+            try:
+                if self._thread == "eventlet":
+                    # see: https://eventlet.net/doc/threading.html
+                    eventlet.tpool.execute(c.perform)  # type: ignore
+                elif self._thread == "gevent":
+                    # see: https://www.gevent.org/api/gevent.threadpool.html
+                    gevent.get_hub().threadpool.spawn(c.perform).get()  # type: ignore
+                else:
+                    c.perform()
+            except CurlError as e:
+                rsp = self._parse_response(c, buffer, header_buffer, default_encoding)
+                rsp.request = req
+                error = code2error(e.code, str(e))
+                raise error(str(e), e.code, rsp) from e
+            else:
+                rsp = self._parse_response(c, buffer, header_buffer, default_encoding)
+                rsp.request = req
+                return rsp
+            finally:
+                c.reset()
+
+    def head(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="HEAD", url=url, **kwargs)
+
+    def get(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="GET", url=url, **kwargs)
+
+    def post(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="POST", url=url, **kwargs)
+
+    def put(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="PUT", url=url, **kwargs)
+
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="PATCH", url=url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="DELETE", url=url, **kwargs)
+
+    def options(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="OPTIONS", url=url, **kwargs)
+
+    def trace(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="TRACE", url=url, **kwargs)
+
+    def query(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="QUERY", url=url, **kwargs)
+
+
+class AsyncSession(BaseSession[R]):
+    """An async request session, cookies and connections will be reused."""
+
+    def __init__(
+        self,
+        *,
+        loop=None,
+        async_curl: Optional[AsyncCurl] = None,
+        max_clients: int = 10,
+        **kwargs: Unpack[BaseSessionParams[R]],
+    ):
+        """
+        Parameters set in the init method will be override by the same parameter in request method.
+
+        Parameters:
+            loop: loop to use, if not provided, the running loop will be used.
+            async_curl: [AsyncCurl](/api/curl_cffi#curl_cffi.AsyncCurl) object to use.
+            max_clients: maxmium curl handle to use in the session,
+                this will affect the concurrency ratio.
+            headers: headers to use in the session.
+            cookies: cookies to add in the session.
+            auth: HTTP basic auth, a tuple of (username, password), only basic auth is supported.
+            proxies: dict of proxies to use, format: {"http": proxy_url, "https": proxy_url}.
+            proxy: proxy to use, format: "http://proxy_url".
+                Cannot be used with the above parameter.
+            proxy_auth: HTTP basic auth for proxy, a tuple of (username, password).
+            base_url: absolute url to use for relative urls.
+            params: query string for the session.
+            verify: whether to verify https certs.
+            timeout: how many seconds to wait before giving up.
+            trust_env: use http_proxy/https_proxy and other environments, default True.
+            allow_redirects: whether to allow redirection.
+            max_redirects: max redirect counts, default 30, use -1 for unlimited.
+            impersonate: which browser version to impersonate in the session.
+            ja3: ja3 string to impersonate in the session.
+            akamai: akamai string to impersonate in the session.
+            extra_fp: extra fingerprints options, in complement to ja3 and akamai strings.
+            default_encoding: encoding for decoding response content if charset is not found
+                in headers. Defaults to "utf-8". Can be set to a callable for automatic detection.
+            cert: a tuple of (cert, key) filenames for client cert.
+            response_class: A customized subtype of ``Response`` to use.
+
+        Notes:
+            This class can be used as a context manager, and it's recommended to use via
+            ``async with``.
+            However, unlike aiohttp, it is not required to use ``with``.
+
+        .. code-block:: python
+
+            from curl_cffi.requests import AsyncSession
+
+            # recommended.
+            async with AsyncSession() as s:
+                r = await s.get("https://example.com")
+
+            s = AsyncSession()  # it also works.
+        """
+        super().__init__(**kwargs)
+        self._loop = loop
+        self._acurl = async_curl
+        self.max_clients = max_clients
+        self.init_pool()
+
+    @property
+    def loop(self):
+        if self._loop is None:
+            self._loop = asyncio.get_running_loop()
+        return self._loop
+
+    @property
+    def acurl(self):
+        if self._acurl is None:
+            self._acurl = AsyncCurl(loop=self.loop)
+        return self._acurl
+
+    def init_pool(self):
+        self.pool = asyncio.LifoQueue(self.max_clients)
+        while True:
+            try:
+                self.pool.put_nowait(None)
+            except asyncio.QueueFull:
+                break
+
+    async def pop_curl(self):
+        curl = await self.pool.get()
+        if curl is None:
+            curl = Curl(debug=self.debug)
+        # XXX: This may be related to proxy rotation
+        # curl.setopt(CurlOpt.FRESH_CONNECT, 1)
+        # curl.setopt(CurlOpt.FORBID_REUSE, 1)
+        return curl
+
+    def push_curl(self, curl):
+        with suppress(asyncio.QueueFull):
+            self.pool.put_nowait(curl)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()
+        return None
+
+    async def close(self) -> None:
+        """Close the session."""
+        await self.acurl.close()
+        self._closed = True
+        while True:
+            try:
+                curl = self.pool.get_nowait()
+                if curl:
+                    curl.close()
+            except asyncio.QueueEmpty:
+                break
+
+    def release_curl(self, curl):
+        curl.clean_after_perform()
+        if not self._closed:
+            self.acurl.remove_handle(curl)
+            curl.reset()
+            # curl.setopt(CurlOpt.PIPEWAIT, 1)
+            self.push_curl(curl)
+        else:
+            curl.close()
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: HttpMethod,
+        url: str,
+        **kwargs: Unpack[StreamRequestParams],
+    ):
+        """Equivalent to ``async with request(..., stream=True) as r:``"""
+        rsp = await self.request(method=method, url=url, **kwargs, stream=True)
+        try:
+            yield rsp
+        finally:
+            await rsp.aclose()
+
+    async def ws_connect(
+        self,
+        url: str,
+        autoclose: bool = True,
+        params: Optional[Union[Dict, List, Tuple]] = None,
+        headers: Optional[HeaderTypes] = None,
+        cookies: Optional[CookieTypes] = None,
+        auth: Optional[Tuple[str, str]] = None,
+        timeout: Optional[Union[float, Tuple[float, float], object]] = not_set,
+        allow_redirects: Optional[bool] = None,
+        max_redirects: Optional[int] = None,
+        proxies: Optional[ProxySpec] = None,
+        proxy: Optional[str] = None,
+        proxy_auth: Optional[Tuple[str, str]] = None,
+        verify: Optional[bool] = None,
+        referer: Optional[str] = None,
+        accept_encoding: Optional[str] = "gzip, deflate, br",
+        impersonate: Optional[BrowserTypeLiteral] = None,
+        ja3: Optional[str] = None,
+        akamai: Optional[str] = None,
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]] = None,
+        default_headers: Optional[bool] = None,
+        quote: Union[str, Literal[False]] = "",
+        http_version: Optional[CurlHttpVersion] = None,
+        interface: Optional[str] = None,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        max_recv_speed: int = 0,
+    ) -> AsyncWebSocket:
+        """Connects to a WebSocket.
+
+        Args:
+            url: url for the requests.
+            autoclose: whether to close the WebSocket after receiving a close frame.
+            params: query string for the requests.
+            headers: headers to send.
+            cookies: cookies to use.
+            auth: HTTP basic auth, a tuple of (username, password), only basic auth is supported.
+            timeout: how many seconds to wait before giving up.
+            allow_redirects: whether to allow redirection.
+            max_redirects: max redirect counts, default 30, use -1 for unlimited.
+            proxies: dict of proxies to use, format: ``{"http": proxy_url, "https": proxy_url}``.
+            proxy: proxy to use, format: "http://user@pass:proxy_url".
+                Can't be used with `proxies` parameter.
+            proxy_auth: HTTP basic auth for proxy, a tuple of (username, password).
+            verify: whether to verify https certs.
+            referer: shortcut for setting referer header.
+            accept_encoding: shortcut for setting accept-encoding header.
+            impersonate: which browser version to impersonate.
+            ja3: ja3 string to impersonate.
+            akamai: akamai string to impersonate.
+            extra_fp: extra fingerprints options, in complement to ja3 and akamai strings.
+            default_headers: whether to set default browser headers.
+            quote: Set characters to be quoted, i.e. percent-encoded. Default safe string
+                is ``!#$%&'()*+,/:;=?@[]~``. If set to a sting, the character will be removed
+                from the safe string, thus quoted. If set to False, the url will be kept as is,
+                without any automatic percent-encoding, you must encode the URL yourself.
+            curl_options: extra curl options to use.
+            http_version: limiting http version, defaults to http2.
+            interface: which interface to use.
+            cert: a tuple of (cert, key) filenames for client cert.
+            max_recv_speed: maximum receive speed, bytes per second.
+        """
+
+        self._check_session_closed()
+
+        curl = await self.pop_curl()
+        set_curl_options(
+            curl=curl,
+            method="GET",
+            url=url,
+            base_url=self.base_url,
+            params_list=[self.params, params],
+            headers_list=[self.headers, headers],
+            cookies_list=[self.cookies, cookies],
+            auth=auth or self.auth,
+            timeout=self.timeout if timeout is not_set else timeout,
+            allow_redirects=self.allow_redirects if allow_redirects is None else allow_redirects,
+            max_redirects=self.max_redirects if max_redirects is None else max_redirects,
+            proxies_list=[self.proxies, proxies],
+            proxy=proxy,
+            proxy_auth=proxy_auth or self.proxy_auth,
+            verify_list=[self.verify, verify],
+            referer=referer,
+            accept_encoding=accept_encoding,
+            impersonate=impersonate or self.impersonate,
+            ja3=ja3 or self.ja3,
+            akamai=akamai or self.akamai,
+            extra_fp=extra_fp or self.extra_fp,
+            default_headers=self.default_headers if default_headers is None else default_headers,
+            quote=quote,
+            http_version=http_version or self.http_version,
+            interface=interface or self.interface,
+            max_recv_speed=max_recv_speed,
+            cert=cert or self.cert,
+            queue_class=asyncio.Queue,
+            event_class=asyncio.Event,
+        )
+        curl.setopt(CurlOpt.CONNECT_ONLY, 2)  # https://curl.se/docs/websocket.html
+
+        await self.loop.run_in_executor(None, curl.perform)
+        return AsyncWebSocket(
+            cast(AsyncSession[Response], self),
+            curl,
+            autoclose=autoclose,
+        )
+
+    async def request(
+        self,
+        method: HttpMethod,
+        url: str,
+        params: Optional[Union[Dict, List, Tuple]] = None,
+        data: Optional[Union[Dict[str, str], List[Tuple], str, BytesIO, bytes]] = None,
+        json: Optional[dict] = None,
+        headers: Optional[HeaderTypes] = None,
+        cookies: Optional[CookieTypes] = None,
+        files: Optional[Dict] = None,
+        auth: Optional[Tuple[str, str]] = None,
+        timeout: Optional[Union[float, Tuple[float, float], object]] = not_set,
+        allow_redirects: Optional[bool] = None,
+        max_redirects: Optional[int] = None,
+        proxies: Optional[ProxySpec] = None,
+        proxy: Optional[str] = None,
+        proxy_auth: Optional[Tuple[str, str]] = None,
+        verify: Optional[bool] = None,
+        referer: Optional[str] = None,
+        accept_encoding: Optional[str] = "gzip, deflate, br",
+        content_callback: Optional[Callable] = None,
+        impersonate: Optional[BrowserTypeLiteral] = None,
+        ja3: Optional[str] = None,
+        akamai: Optional[str] = None,
+        extra_fp: Optional[Union[ExtraFingerprints, ExtraFpDict]] = None,
+        default_headers: Optional[bool] = None,
+        default_encoding: Union[str, Callable[[bytes], str]] = "utf-8",
+        quote: Union[str, Literal[False]] = "",
+        http_version: Optional[CurlHttpVersion] = None,
+        interface: Optional[str] = None,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        stream: Optional[bool] = None,
+        max_recv_speed: int = 0,
+        multipart: Optional[CurlMime] = None,
+    ):
+        """Send the request, see ``curl_cffi.requests.request`` for details on parameters."""
+
+        self._check_session_closed()
+
+        curl = await self.pop_curl()
+        req, buffer, header_buffer, q, header_recved, quit_now = set_curl_options(
+            curl=curl,
+            method=method,
+            url=url,
+            params_list=[self.params, params],
+            base_url=self.base_url,
+            data=data,
+            json=json,
+            headers_list=[self.headers, headers],
+            cookies_list=[self.cookies, cookies],
+            files=files,
+            auth=auth or self.auth,
+            timeout=self.timeout if timeout is not_set else timeout,
+            allow_redirects=self.allow_redirects if allow_redirects is None else allow_redirects,
+            max_redirects=self.max_redirects if max_redirects is None else max_redirects,
+            proxies_list=[self.proxies, proxies],
+            proxy=proxy,
+            proxy_auth=proxy_auth or self.proxy_auth,
+            verify_list=[self.verify, verify],
+            referer=referer,
+            accept_encoding=accept_encoding,
+            content_callback=content_callback,
+            impersonate=impersonate or self.impersonate,
+            ja3=ja3 or self.ja3,
+            akamai=akamai or self.akamai,
+            extra_fp=extra_fp or self.extra_fp,
+            default_headers=self.default_headers if default_headers is None else default_headers,
+            quote=quote,
+            http_version=http_version or self.http_version,
+            interface=interface or self.interface,
+            stream=stream,
+            max_recv_speed=max_recv_speed,
+            multipart=multipart,
+            cert=cert or self.cert,
+            curl_options=self.curl_options,
+            queue_class=asyncio.Queue,
+            event_class=asyncio.Event,
+        )
+        if stream:
+            task = self.acurl.add_handle(curl)
+
+            async def perform():
+                try:
+                    await task
+                except CurlError as e:
+                    rsp = self._parse_response(curl, buffer, header_buffer, default_encoding)
+                    rsp.request = req
+                    cast(asyncio.Queue, q).put_nowait(RequestException(str(e), e.code, rsp))
+                finally:
+                    if not cast(asyncio.Event, header_recved).is_set():
+                        cast(asyncio.Event, header_recved).set()
+                    # None acts as a sentinel
+                    await cast(asyncio.Queue, q).put(None)
+
+            def cleanup(fut):
+                self.release_curl(curl)
+
+            stream_task = asyncio.create_task(perform())
+            stream_task.add_done_callback(cleanup)
+
+            await cast(asyncio.Event, header_recved).wait()
+
+            # Unlike threads, coroutines does not use preemptive scheduling.
+            # For asyncio, there is no need for a header_parsed event, the
+            # _parse_response will execute in the foreground, no background tasks running.
+            rsp = self._parse_response(curl, buffer, header_buffer, default_encoding)
+
+            first_element = _peek_aio_queue(cast(asyncio.Queue, q))
+            if isinstance(first_element, RequestException):
+                self.release_curl(curl)
+                raise first_element
+
+            rsp.request = req
+            rsp.astream_task = stream_task
+            rsp.quit_now = quit_now
+            rsp.queue = q
+            return rsp
+        else:
+            try:
+                task = self.acurl.add_handle(curl)
+                await task
+            except CurlError as e:
+                rsp = self._parse_response(curl, buffer, header_buffer, default_encoding)
+                rsp.request = req
+                error = code2error(e.code, str(e))
+                raise error(str(e), e.code, rsp) from e
+            else:
+                rsp = self._parse_response(curl, buffer, header_buffer, default_encoding)
+                rsp.request = req
+                return rsp
+            finally:
+                self.release_curl(curl)
+
+    def head(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="HEAD", url=url, **kwargs)
+
+    def get(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="GET", url=url, **kwargs)
+
+    def post(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="POST", url=url, **kwargs)
+
+    def put(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="PUT", url=url, **kwargs)
+
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="PATCH", url=url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="DELETE", url=url, **kwargs)
+
+    def options(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="OPTIONS", url=url, **kwargs)
+
+    def trace(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="TRACE", url=url, **kwargs)
+
+    def query(self, url: str, **kwargs: Unpack[RequestParams]):
+        return self.request(method="QUERY", url=url, **kwargs)