rnet.pyi

# This file is automatically generated by pyo3_stub_gen
# ruff: noqa: E501, F401

import builtins
import typing
from enum import Enum, auto

class BlockingClient:
    r"""
    A blocking client for making HTTP requests.
    """
    user_agent: typing.Optional[builtins.str]
    headers: typing.Optional[dict]
    def __new__(cls,**kwds): ...
    def get_cookies(self, url:str) -> list:
        r"""
        Returns the cookies for the given URL.
        
        # Arguments
        
        * `url` - The URL to get the cookies for.
        
        # Returns
        
        A list of cookie strings.
        """
        ...

    def set_cookies(self, url:str, value:typing.List[str]) -> None:
        r"""
        Sets cookies for the given URL.
        
        # Arguments
        
        * `url` - The URL to set the cookies for.
        * `value` - A list of cookie strings to set.
        
        # Returns
        
        A `PyResult` indicating success or failure.
        """
        ...

    def update(self, **kwds) -> None:
        r"""
        Updates the client with the given parameters.
        
        # Arguments
        * `**kwds` - The parameters to update the client with.
        
            impersonate: typing.Optional[Impersonate]
            impersonate_os: typing.Optional[ImpersonateOS]
            impersonate_skip_http2: typing.Optional[builtins.bool]
            impersonate_skip_headers: typing.Optional[builtins.bool]
            headers: typing.Optional[typing.Dict[str, bytes]]
            headers_order: typing.Optional[typing.List[str]]
            proxies: typing.Optional[builtins.list[Proxy]]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
        
        # Examples
        
        ```python
        import rnet
        
        client = rnet.BlockingClient()
        client.update(
           impersonate=rnet.Impersonate.Firefox135,
           headers={"X-My-Header": "value"},
           proxies=[rnet.Proxy.all("http://proxy.example.com:8080")],
        )
        ```
        """
        ...

    def request(self, method:Method, url:str, kwds:typing.Optional[typing.Dict[str, typing.Any]]) -> BlockingResponse:
        r"""
        Sends a request with the given method and URL.
        
        # Arguments
        
        * `method` - The method to use for the request.
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.request(Method.GET, "https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def websocket(self, url:str, **kwds) -> BlockingWebSocket:
        r"""
        Sends a WebSocket request.
        
        # Arguments
        
        * `url` - The URL to send the WebSocket request to.
        * `**kwds` - Additional WebSocket request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            protocols: typing.Optional[builtins.list[builtins.str]]
            use_http2: typing.Optional[builtins.bool]
            auth: typing.Optional[builtins.str]
            bearer_auth: typing.Optional[builtins.str]
            basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
            query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
            read_buffer_size: typing.Optional[builtins.int]
            write_buffer_size: typing.Optional[builtins.int]
            max_write_buffer_size: typing.Optional[builtins.int]
            max_message_size: typing.Optional[builtins.int]
            max_frame_size: typing.Optional[builtins.int]
            accept_unmasked_frames: typing.Optional[builtins.bool]
        
        # Returns
        
        A `WebSocket` object representing the WebSocket connection.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        
        async def main():
            client = rnet.BlockingClient()
            ws = client.websocket("wss://echo.websocket.org")
            ws.send(rnet.Message.from_text("Hello, WebSocket!"))
            message = ws.recv()
            print("Received:", message.data)
            ws.close()
        
        asyncio.run(main())
        ```
        """
        ...

    def trace(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.trace("https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def options(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.options("https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def head(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.head("https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def delete(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.delete("https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def patch(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.patch("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def put(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.put("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def post(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.post("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def get(self, url:str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.BlockingClient()
            response = client.get("https://httpbin.org/anything")
            print(response.text())
        
        asyncio.run(main())
        ```
        """
        ...


class BlockingResponse:
    r"""
    A bloking response from a request.
    """
    url: builtins.str
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: typing.Optional[dict]
    cookies: typing.Optional[dict]
    content_length: builtins.int
    remote_addr: typing.Optional[SocketAddr]
    encoding: builtins.str
    def __enter__(self) -> BlockingResponse:
        ...

    def __exit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> None:
        ...

    def peer_certificate(self) -> typing.Optional[typing.Any]:
        r"""
        Returns the TLS peer certificate of the response.
        
        # Returns
        
        A Python object representing the TLS peer certificate of the response.
        """
        ...

    def text(self) -> builtins.str:
        r"""
        Returns the text content of the response.
        
        # Returns
        
        A Python object representing the text content of the response.
        """
        ...

    def text_with_charset(self, encoding:builtins.str) -> builtins.str:
        r"""
        Returns the text content of the response with a specific charset.
        
        # Arguments
        
        * `default_encoding` - The default encoding to use if the charset is not specified.
        
        # Returns
        
        A Python object representing the text content of the response.
        """
        ...

    def json(self) -> typing.Any:
        r"""
        Returns the JSON content of the response.
        
        # Returns
        
        A Python object representing the JSON content of the response.
        """
        ...

    def bytes(self) -> typing.Any:
        r"""
        Returns the bytes content of the response.
        
        # Returns
        
        A Python object representing the bytes content of the response.
        """
        ...

    def stream(self) -> BlockingStreamer:
        r"""
        Convert the response into a `Stream` of `Bytes` from the body.
        
        # Returns
        
        A Python object representing the stream content of the response.
        """
        ...

    def close(self) -> None:
        r"""
        Closes the response connection.
        """
        ...


class BlockingStreamer:
    r"""
    A blocking byte stream response.
    An asynchronous iterator yielding data chunks from the response stream.
    Used for streaming response content.
    Employed in the `stream` method of the `Response` class.
    Utilized in an asynchronous for loop in Python.
    """
    def __iter__(self) -> BlockingStreamer:
        ...

    def __next__(self) -> typing.Any:
        ...

    def __enter__(self) -> BlockingStreamer:
        ...

    def __exit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> None:
        ...


class BlockingWebSocket:
    r"""
    A blocking WebSocket response.
    """
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: typing.Optional[dict]
    remote_addr: typing.Optional[SocketAddr]
    def __iter__(self) -> BlockingWebSocket:
        ...

    def __next__(self) -> Message:
        ...

    def __enter__(self) -> BlockingWebSocket:
        ...

    def __exit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> None:
        ...

    def protocol(self) -> typing.Optional[builtins.str]:
        r"""
        Returns the WebSocket protocol.
        
        # Returns
        
        An optional string representing the WebSocket protocol.
        """
        ...

    def recv(self) -> typing.Optional[Message]:
        r"""
        Receives a message from the WebSocket.
        
        # Returns
        
        A `PyResult` containing a `Bound` object with the received message, or `None` if no message is received.
        """
        ...

    def send(self, message:Message) -> None:
        r"""
        Sends a message to the WebSocket.
        
        # Arguments
        
        * `message` - The message to send.
        
        # Returns
        
        A `PyResult` containing a `Bound` object.
        """
        ...

    def close(self, code:typing.Optional[builtins.int]=None, reason:typing.Optional[builtins.str]=None) -> None:
        r"""
        Closes the WebSocket connection.
        
        # Arguments
        
        * `code` - An optional close code.
        * `reason` - An optional reason for closing.
        
        # Returns
        
        A `PyResult` containing a `Bound` object.
        """
        ...


class Client:
    r"""
    A client for making HTTP requests.
    """
    user_agent: typing.Optional[builtins.str]
    headers: typing.Optional[dict]
    def __new__(cls,**kwds): ...
    def get_cookies(self, url:str) -> list:
        r"""
        Returns the cookies for the given URL.
        
        # Arguments
        
        * `url` - The URL to get the cookies for.
        
        # Returns
        
        A list of cookie strings.
        
        # Examples
        
        ```python
        import rnet
        
        client = rnet.Client(cookie_store=True)
        cookies = client.get_cookies("https://example.com")
        print(cookies)
        ```
        """
        ...

    def set_cookies(self, url:str, cookies:typing.List[str]) -> None:
        r"""
        Sets cookies for the given URL.
        
        # Arguments
        
        * `url` - The URL to set the cookies for.
        * `value` - A list of cookie strings to set.
        
        # Returns
        
        A `PyResult` indicating success or failure.
        
        # Examples
        
        ```python
        import rnet
        
        client = rnet.Client(cookie_store=True)
        client.set_cookies("https://example.com", ["cookie1=value1", "cookie2=value2"])
        ```
        """
        ...

    def update(self, **kwds) -> None:
        r"""
        Updates the client with the given parameters.
        
        # Arguments
        * `**kwds` - The parameters to update the client with.
        
            impersonate: typing.Optional[Impersonate]
            impersonate_os: typing.Optional[ImpersonateOS]
            impersonate_skip_http2: typing.Optional[builtins.bool]
            impersonate_skip_headers: typing.Optional[builtins.bool]
            headers: typing.Optional[typing.Dict[str, bytes]]
            headers_order: typing.Optional[typing.List[str]]
            proxies: typing.Optional[builtins.list[Proxy]]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
        
        # Examples
        
        ```python
        import rnet
        
        client = rnet.Client()
        client.update(
           impersonate=rnet.Impersonate.Firefox135,
           headers={"X-My-Header": "value"},
           proxies=[rnet.Proxy.all("http://proxy.example.com:8080")],
        )
        ```
        """
        ...

    def request(self, method:Method, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given method and URL.
        
        # Arguments
        
        * `method` - The method to use for the request.
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.request(Method.GET, "https://httpbin.org/anything")
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def websocket(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a WebSocket request.
        
        # Arguments
        
        * `url` - The URL to send the WebSocket request to.
        * `**kwds` - Additional WebSocket request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            protocols: typing.Optional[builtins.list[builtins.str]]
            use_http2: typing.Optional[builtins.bool]
            auth: typing.Optional[builtins.str]
            bearer_auth: typing.Optional[builtins.str]
            basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
            query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
            read_buffer_size: typing.Optional[builtins.int]
            write_buffer_size: typing.Optional[builtins.int]
            max_write_buffer_size: typing.Optional[builtins.int]
            max_message_size: typing.Optional[builtins.int]
            max_frame_size: typing.Optional[builtins.int]
            accept_unmasked_frames: typing.Optional[builtins.bool]
        
        # Returns
        
        A `WebSocket` object representing the WebSocket connection.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        
        async def main():
            client = rnet.Client()
            ws = await client.websocket("wss://echo.websocket.org")
            await ws.send(rnet.Message.from_text("Hello, WebSocket!"))
            message = await ws.recv()
            print("Received:", message.data)
            await ws.close()
        
        asyncio.run(main())
        ```
        """
        ...

    def trace(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.trace("https://httpbin.org/anything")
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def options(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.options("https://httpbin.org/anything")
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def patch(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.patch("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def delete(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.delete("https://httpbin.org/anything")
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def put(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.put("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def post(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.post("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...

    def head(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.head("https://httpbin.org/anything")
            print(response.status)
        
        asyncio.run(main())
        ```
        """
        ...

    def get(self, url:str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL
        
        # Arguments
        
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.
        
            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]
        
        # Returns
        
        A `Response` object.
        
        # Examples
        
        ```python
        import rnet
        import asyncio
        from rnet import Method
        
        async def main():
            client = rnet.Client()
            response = await client.get("https://httpbin.org/anything")
            print(await response.text())
        
        asyncio.run(main())
        ```
        """
        ...


class Message:
    r"""
    A WebSocket message.
    """
    data: typing.Optional[typing.Any]
    text: typing.Optional[builtins.str]
    binary: typing.Optional[typing.Any]
    ping: typing.Optional[typing.Any]
    pong: typing.Optional[typing.Any]
    close: typing.Optional[tuple[builtins.int, typing.Optional[builtins.str]]]
    def __str__(self) -> builtins.str:
        ...

    def __repr__(self) -> builtins.str:
        ...

    @staticmethod
    def text_from_json(json:typing.Any) -> Message:
        r"""
        Creates a new text message from the JSON representation.
        
        # Arguments
        * `json` - The JSON representation of the message.
        
        # Returns
        
        A new `Message` instance containing the message.
        """
        ...

    @staticmethod
    def binary_from_json(json:typing.Any) -> Message:
        r"""
        Creates a new binary message from the JSON representation.
        
        # Arguments
        * `json` - The JSON representation of the message.
        
        # Returns
        
        A new `Message` instance containing the message.
        """
        ...

    @staticmethod
    def from_text(text:str) -> Message:
        r"""
        Creates a new text message.
        
        # Arguments
        
        * `text` - The text content of the message.
        
        # Returns
        
        A new `Message` instance containing the text message.
        """
        ...

    @staticmethod
    def from_binary(data:bytes) -> Message:
        r"""
        Creates a new binary message.
        
        # Arguments
        
        * `data` - The binary data of the message.
        
        # Returns
        
        A new `Message` instance containing the binary message.
        """
        ...

    @staticmethod
    def from_ping(data:bytes) -> Message:
        r"""
        Creates a new ping message.
        
        # Arguments
        
        * `data` - The ping data of the message.
        
        # Returns
        
        A new `Message` instance containing the ping message.
        """
        ...

    @staticmethod
    def from_pong(data:bytes) -> Message:
        r"""
        Creates a new pong message.
        
        # Arguments
        
        * `data` - The pong data of the message.
        
        # Returns
        
        A new `Message` instance containing the pong message.
        """
        ...

    @staticmethod
    def from_close(code:builtins.int, reason:typing.Optional[builtins.str]=None) -> Message:
        r"""
        Creates a new close message.
        
        # Arguments
        
        * `code` - The close code.
        * `reason` - An optional reason for closing.
        
        # Returns
        
        A new `Message` instance containing the close message.
        """
        ...

    def json(self) -> typing.Any:
        r"""
        Returns the JSON representation of the message.
        
        # Returns
        
        A `PyResult` containing the JSON representation of the message.
        """
        ...


class Multipart:
    r"""
    A multipart form for a request.
    """
    def __new__(cls,*parts): ...
    ...

class Part:
    r"""
    A part of a multipart form.
    """
    def __new__(cls,name:builtins.str, value:typing.Any, filename:typing.Optional[builtins.str]=None, mime:typing.Optional[builtins.str]=None): ...
    ...

class Proxy:
    r"""
    A proxy server for a request.
    """
    @staticmethod
    def http(url:builtins.str, username:typing.Optional[builtins.str]=None, password:typing.Optional[builtins.str]=None, custom_http_auth:typing.Optional[builtins.str]=None, exclusion:typing.Optional[builtins.str]=None) -> Proxy:
        r"""
        Creates a new HTTP proxy.
        
        This method sets up a proxy server for HTTP requests.
        
        # Arguments
        
        * `url` - The URL of the proxy server.
        * `username` - Optional username for proxy authentication.
        * `password` - Optional password for proxy authentication.
        * `custom_http_auth` - Optional custom HTTP authentication header value.
        * `exclusion` - Optional list of domains to exclude from proxying.
        
        # Returns
        
        A new `Proxy` instance.
        
        # Examples
        
        ```python
        import rnet
        
        proxy = rnet.Proxy.http("http://proxy.example.com")
        ```
        """
        ...

    @staticmethod
    def https(url:builtins.str, username:typing.Optional[builtins.str]=None, password:typing.Optional[builtins.str]=None, custom_http_auth:typing.Optional[builtins.str]=None, exclusion:typing.Optional[builtins.str]=None) -> Proxy:
        r"""
        Creates a new HTTPS proxy.
        
        This method sets up a proxy server for HTTPS requests.
        
        # Arguments
        
        * `url` - The URL of the proxy server.
        * `username` - Optional username for proxy authentication.
        * `password` - Optional password for proxy authentication.
        * `custom_http_auth` - Optional custom HTTP authentication header value.
        * `exclusion` - Optional list of domains to exclude from proxying.
        
        # Returns
        
        A new `Proxy` instance.
        
        # Examples
        
        ```python
        import rnet
        
        proxy = rnet.Proxy.https("https://proxy.example.com")
        ```
        """
        ...

    @staticmethod
    def all(url:builtins.str, username:typing.Optional[builtins.str]=None, password:typing.Optional[builtins.str]=None, custom_http_auth:typing.Optional[builtins.str]=None, exclusion:typing.Optional[builtins.str]=None) -> Proxy:
        r"""
        Creates a new proxy for all protocols.
        
        This method sets up a proxy server for all types of requests (HTTP, HTTPS, etc.).
        
        # Arguments
        
        * `url` - The URL of the proxy server.
        * `username` - Optional username for proxy authentication.
        * `password` - Optional password for proxy authentication.
        * `custom_http_auth` - Optional custom HTTP authentication header value.
        * `exclusion` - Optional list of domains to exclude from proxying.
        
        # Returns
        
        A new `Proxy` instance.
        
        # Examples
        
        ```python
        import rnet
        
        proxy = rnet.Proxy.all("https://proxy.example.com")
        ```
        """
        ...


class Response:
    r"""
    A response from a request.
    
    # Examples
    
    ```python
    import asyncio
    import rnet
    
    async def main():
        response = await rnet.get("https://www.rust-lang.org")
        print("Status Code: ", response.status_code)
        print("Version: ", response.version)
        print("Response URL: ", response.url)
        print("Headers: ", response.headers)
        print("Content-Length: ", response.content_length)
        print("Encoding: ", response.encoding)
        print("Remote Address: ", response.remote_addr)
    
        text_content = await response.text()
        print("Text: ", text_content)
    
    if __name__ == "__main__":
        asyncio.run(main())
    ```
    """
    url: builtins.str
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: typing.Optional[dict]
    cookies: typing.Optional[dict]
    content_length: builtins.int
    remote_addr: typing.Optional[SocketAddr]
    encoding: builtins.str
    def __aenter__(self) -> typing.Any:
        ...

    def __aexit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> typing.Any:
        ...

    def peer_certificate(self) -> typing.Optional[typing.Any]:
        r"""
        Returns the TLS peer certificate of the response.
        
        # Returns
        
        A Python object representing the TLS peer certificate of the response.
        """
        ...

    def text(self) -> typing.Any:
        r"""
        Returns the text content of the response.
        
        # Returns
        
        A Python object representing the text content of the response.
        """
        ...

    def text_with_charset(self, encoding:builtins.str) -> typing.Any:
        r"""
        Returns the text content of the response with a specific charset.
        
        # Arguments
        
        * `default_encoding` - The default encoding to use if the charset is not specified.
        
        # Returns
        
        A Python object representing the text content of the response.
        """
        ...

    def json(self) -> typing.Any:
        r"""
        Returns the JSON content of the response.
        
        # Returns
        
        A Python object representing the JSON content of the response.
        """
        ...

    def bytes(self) -> typing.Any:
        r"""
        Returns the bytes content of the response.
        
        # Returns
        
        A Python object representing the bytes content of the response.
        """
        ...

    def stream(self) -> Streamer:
        r"""
        Convert the response into a `Stream` of `Bytes` from the body.
        
        # Returns
        
        A Python object representing the stream content of the response.
        """
        ...

    def close(self) -> None:
        r"""
        Closes the response connection.
        """
        ...


class SocketAddr:
    r"""
    A IP socket address.
    """
    def __str__(self) -> builtins.str:
        ...

    def ip(self) -> typing.Any:
        r"""
        Returns the IP address of the socket address.
        """
        ...

    def port(self) -> builtins.int:
        r"""
        Returns the port number of the socket address.
        """
        ...


class StatusCode:
    r"""
    HTTP status code.
    """
    def __str__(self) -> builtins.str:
        ...

    def __repr__(self) -> builtins.str:
        ...

    def as_int(self) -> builtins.int:
        r"""
        Return the status code as an integer.
        """
        ...

    def is_informational(self) -> builtins.bool:
        r"""
        Check if status is within 100-199.
        """
        ...

    def is_success(self) -> builtins.bool:
        r"""
        Check if status is within 200-299.
        """
        ...

    def is_redirection(self) -> builtins.bool:
        r"""
        Check if status is within 300-399.
        """
        ...

    def is_client_error(self) -> builtins.bool:
        r"""
        Check if status is within 400-499.
        """
        ...

    def is_server_error(self) -> builtins.bool:
        r"""
        Check if status is within 500-599.
        """
        ...


class Streamer:
    r"""
    A byte stream response.
    An asynchronous iterator yielding data chunks from the response stream.
    Used to stream response content.
    Implemented in the `stream` method of the `Response` class.
    Can be used in an asynchronous for loop in Python.
    
    # Examples
    
    ```python
    import asyncio
    import rnet
    from rnet import Method, Impersonate
    
    async def main():
        resp = await rnet.get("https://httpbin.org/stream/20")
        print("Status Code: ", resp.status_code)
        print("Version: ", resp.version)
        print("Response URL: ", resp.url)
        print("Headers: ", resp.headers)
        print("Content-Length: ", resp.content_length)
        print("Encoding: ", resp.encoding)
        print("Remote Address: ", resp.remote_addr)
    
        async with resp.stream() as streamer:
            async for chunk in streamer:
                print("Chunk: ", chunk)
                await asyncio.sleep(0.1)
    
    if __name__ == "__main__":
        asyncio.run(main())
    ```
    """
    def __aiter__(self) -> Streamer:
        ...

    def __anext__(self) -> typing.Any:
        ...

    def __aenter__(self) -> typing.Any:
        ...

    def __aexit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> typing.Any:
        ...


class WebSocket:
    r"""
    A WebSocket response.
    """
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: typing.Optional[dict]
    remote_addr: typing.Optional[SocketAddr]
    def __aiter__(self) -> WebSocket:
        ...

    def __anext__(self) -> typing.Any:
        ...

    def __aenter__(self) -> typing.Any:
        ...

    def __aexit__(self, _exc_type:typing.Any, _exc_value:typing.Any, _traceback:typing.Any) -> typing.Any:
        ...

    def protocol(self) -> typing.Optional[builtins.str]:
        r"""
        Returns the WebSocket protocol.
        
        # Returns
        
        An optional string representing the WebSocket protocol.
        """
        ...

    def recv(self) -> typing.Any:
        r"""
        Receives a message from the WebSocket.
        
        # Arguments
        
        * `py` - The Python runtime.
        
        # Returns
        
        A `PyResult` containing a `Bound` object with the received message, or `None` if no message is received.
        """
        ...

    def send(self, message:Message) -> typing.Any:
        r"""
        Sends a message to the WebSocket.
        
        # Arguments
        
        * `py` - The Python runtime.
        * `message` - The message to send.
        
        # Returns
        
        A `PyResult` containing a `Bound` object.
        """
        ...

    def close(self, code:typing.Optional[builtins.int]=None, reason:typing.Optional[builtins.str]=None) -> typing.Any:
        r"""
        Closes the WebSocket connection.
        
        # Arguments
        
        * `py` - The Python runtime.
        * `code` - An optional close code.
        * `reason` - An optional reason for closing.
        
        # Returns
        
        A `PyResult` containing a `Bound` object.
        """
        ...


class Impersonate(Enum):
    r"""
    An impersonate.
    """
    Chrome100 = auto()
    Chrome101 = auto()
    Chrome104 = auto()
    Chrome105 = auto()
    Chrome106 = auto()
    Chrome107 = auto()
    Chrome108 = auto()
    Chrome109 = auto()
    Chrome114 = auto()
    Chrome116 = auto()
    Chrome117 = auto()
    Chrome118 = auto()
    Chrome119 = auto()
    Chrome120 = auto()
    Chrome123 = auto()
    Chrome124 = auto()
    Chrome126 = auto()
    Chrome127 = auto()
    Chrome128 = auto()
    Chrome129 = auto()
    Chrome130 = auto()
    Chrome131 = auto()
    Chrome132 = auto()
    Chrome133 = auto()
    Edge101 = auto()
    Edge122 = auto()
    Edge127 = auto()
    Edge131 = auto()
    Firefox109 = auto()
    Firefox117 = auto()
    Firefox128 = auto()
    Firefox133 = auto()
    Firefox135 = auto()
    FirefoxPrivate135 = auto()
    FirefoxAndroid135 = auto()
    Firefox136 = auto()
    FirefoxPrivate136 = auto()
    SafariIos17_2 = auto()
    SafariIos17_4_1 = auto()
    SafariIos16_5 = auto()
    Safari15_3 = auto()
    Safari15_5 = auto()
    Safari15_6_1 = auto()
    Safari16 = auto()
    Safari16_5 = auto()
    Safari17_0 = auto()
    Safari17_2_1 = auto()
    Safari17_4_1 = auto()
    Safari17_5 = auto()
    Safari18 = auto()
    SafariIPad18 = auto()
    Safari18_2 = auto()
    Safari18_3 = auto()
    SafariIos18_1_1 = auto()
    OkHttp3_9 = auto()
    OkHttp3_11 = auto()
    OkHttp3_13 = auto()
    OkHttp3_14 = auto()
    OkHttp4_9 = auto()
    OkHttp4_10 = auto()
    OkHttp4_12 = auto()
    OkHttp5 = auto()

class ImpersonateOS(Enum):
    r"""
    An impersonate operating system.
    """
    Windows = auto()
    MacOS = auto()
    Linux = auto()
    Android = auto()
    IOS = auto()

class LookupIpStrategy(Enum):
    r"""
    The lookup ip strategy.
    """
    Ipv4Only = auto()
    Ipv6Only = auto()
    Ipv4AndIpv6 = auto()
    Ipv6thenIpv4 = auto()
    Ipv4thenIpv6 = auto()

class Method(Enum):
    r"""
    An HTTP method.
    """
    GET = auto()
    HEAD = auto()
    POST = auto()
    PUT = auto()
    DELETE = auto()
    OPTIONS = auto()
    TRACE = auto()
    PATCH = auto()

class TlsVersion(Enum):
    r"""
    The TLS version.
    """
    TLS_1_0 = auto()
    TLS_1_1 = auto()
    TLS_1_2 = auto()
    TLS_1_3 = auto()

class Version(Enum):
    r"""
    An HTTP version.
    """
    HTTP_09 = auto()
    HTTP_10 = auto()
    HTTP_11 = auto()
    HTTP_2 = auto()
    HTTP_3 = auto()

def delete(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.delete("https://httpbin.org/anything")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def get(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.get("https://httpbin.org/anything")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def head(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.head("https://httpbin.org/anything")
        print(response.status)
    
    asyncio.run(run())
    ```
    """
    ...

def options(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.options("https://httpbin.org/anything")
        print(response.status)
    
    asyncio.run(run())
    ```
    """
    ...

def patch(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.patch("https://httpbin.org/anything")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def post(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.post("https://httpbin.org/anything")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def put(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.put("https://httpbin.org/anything")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def request(method:Method, url:str, **kwds) -> typing.Any:
    r"""
    Make a request with the given parameters.
    
    # Arguments
    
    * `method` - The method to use for the request.
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    from rnet import Method
    
    async def run():
        response = await rnet.request(Method.GET, "https://www.rust-lang.org")
        body = await response.text()
        print(body)
    
    asyncio.run(run())
    ```
    """
    ...

def trace(url:str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.
    
    # Arguments
    
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    
    async def run():
        response = await rnet.trace("https://httpbin.org/anything")
        print(response.status)
    
    asyncio.run(run())
    ```
    """
    ...

def websocket(url:str, **kwds) -> typing.Any:
    r"""
    Make a WebSocket connection with the given parameters.
    
    # Arguments
    
    * `url` - The URL to send the WebSocket request to.
    * `**kwds` - Additional WebSocket request parameters.
    
        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        protocols: typing.Optional[builtins.list[builtins.str]]
        use_http2: typing.Optional[builtins.bool]
        auth: typing.Optional[builtins.str]
        bearer_auth: typing.Optional[builtins.str]
        basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
        query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
        read_buffer_size: typing.Optional[builtins.int]
        write_buffer_size: typing.Optional[builtins.int]
        max_write_buffer_size: typing.Optional[builtins.int]
        max_message_size: typing.Optional[builtins.int]
        max_frame_size: typing.Optional[builtins.int]
        accept_unmasked_frames: typing.Optional[builtins.bool]
    
    # Examples
    
    ```python
    import rnet
    import asyncio
    from rnet import Message
    
    async def run():
        ws = await rnet.websocket("wss://echo.websocket.org")
        await ws.send(Message.from_text("Hello, World!"))
        message = await ws.recv()
        print("Received:", message.data)
        await ws.close()
    
    asyncio.run(run())
    ```
    """
    ...