rnet 3.0.0rc2__cp311-abi3-manylinux_2_34_armv7l.whl → 3.0.0rc4__cp311-abi3-manylinux_2_34_armv7l.whl

rnet/blocking.py

@@ -1,5 +1,5 @@
-from typing import Unpack
-from rnet import ClientParams, Message, Request, Streamer, WebSocketRequest
+import datetime
+from rnet import ClientParams, History, Message, Request, Streamer, WebSocketRequest
 from typing import (
     Optional,
     Any,
@@ -12,59 +12,187 @@ from rnet.header import HeaderMap
 from rnet.cookie import Cookie
 
 
+class Response:
+    r"""
+    A blocking response from a request.
+    """
+
+    url: str
+    r"""
+    Get the URL of the response.
+    """
+
+    status: StatusCode
+    r"""
+    Get the status code of the response.
+    """
+
+    version: Version
+    r"""
+    Get the HTTP version of the response.
+    """
+
+    headers: HeaderMap
+    r"""
+    Get the headers of the response.
+    """
+
+    cookies: List[Cookie]
+    r"""
+    Get the cookies of the response.
+    """
+
+    content_length: Optional[int]
+    r"""
+    Get the content length of the response.
+    """
+
+    remote_addr: Optional[SocketAddr]
+    r"""
+    Get the remote address of the response.
+    """
+
+    local_addr: Optional[SocketAddr]
+    r"""
+    Get the local address of the response.
+    """
+
+    history: List[History]
+    r"""
+    Get the redirect history of the Response.
+    """
+
+    peer_certificate: Optional[bytes]
+    r"""
+    Get the DER encoded leaf certificate of the response.
+    """
+
+    def text(self) -> str:
+        r"""
+        Get the text content of the response.
+        """
+        ...
+
+    def text_with_charset(self, encoding: str) -> str:
+        r"""
+        Get the full response text given a specific encoding.
+        """
+        ...
+
+    def json(self) -> Any:
+        r"""
+        Get the JSON content of the response.
+        """
+
+    def bytes(self) -> bytes:
+        r"""
+        Get the bytes content of the response.
+        """
+        ...
+
+    def stream(self) -> Streamer:
+        r"""
+        Get the response into a `Stream` of `Bytes` from the body.
+        """
+        ...
+
+    def close(self) -> None:
+        r"""
+        Close the response connection.
+        """
+
+    def __enter__(self) -> "Response": ...
+    def __exit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> None: ...
+
+
+class WebSocket:
+    r"""
+    A blocking WebSocket response.
+    """
+
+    status: StatusCode
+    r"""
+    Get the status code of the response.
+    """
+
+    version: Version
+    r"""
+    Get the HTTP version of the response.
+    """
+
+    headers: HeaderMap
+    r"""
+    Get the headers of the response.
+    """
+
+    cookies: List[Cookie]
+    r"""
+    Get the cookies of the response.
+    """
+
+    remote_addr: Optional[SocketAddr]
+    r"""
+    Get the remote address of the response.
+    """
+
+    protocol: Optional[str]
+    r"""
+    Get the WebSocket protocol.
+    """
+
+    def recv(self, timeout: datetime.timedelta | None = None) -> Optional[Message]:
+        r"""
+        Receive a message from the WebSocket.
+        """
+
+    def send(self, message: Message) -> None:
+        r"""
+        Send a message to the WebSocket.
+
+        # Arguments
+
+        * `message` - The message to send.
+        """
+
+    def send_all(self, messages: List[Message]) -> None:
+        r"""
+        Send multiple messages to the WebSocket.
+
+        # Arguments
+
+        * `messages` - The list of messages to send.
+        """
+
+    def close(
+        self,
+        code: int | None = None,
+        reason: str | None = None,
+    ) -> None:
+        r"""
+        Close the WebSocket connection.
+
+        # Arguments
+
+        * `code` - An optional close code.
+        * `reason` - An optional reason for closing.
+        """
+
+    def __enter__(self) -> "WebSocket": ...
+    def __exit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> None: ...
+
+
 class Client:
     r"""
     A blocking client for making HTTP requests.
     """
 
     def __init__(
-        cls,
+        self,
         **kwargs: Unpack[ClientParams],
-    ) -> "Client":
+    ) -> None:
         r"""
         Creates a new blocking Client instance.
 
-        Args:
-            emulation: Browser fingerprint/Emulation config.
-            user_agent: Default User-Agent string.
-            headers: Default request headers.
-            orig_headers: Original request headers (case-sensitive and order).
-            referer: Automatically set Referer.
-            allow_redirects: Allow automatic redirects.
-            max_redirects: Maximum number of redirects.
-            cookie_store: Enable cookie store.
-            lookup_ip_strategy: IP lookup strategy.
-            timeout: Total timeout (seconds).
-            connect_timeout: Connection timeout (seconds).
-            read_timeout: Read timeout (seconds).
-            tcp_keepalive: TCP keepalive time (seconds).
-            tcp_keepalive_interval: TCP keepalive interval (seconds).
-            tcp_keepalive_retries: TCP keepalive retry count.
-            tcp_user_timeout: TCP user timeout (seconds).
-            tcp_nodelay: Enable TCP_NODELAY.
-            tcp_reuse_address: Enable SO_REUSEADDR.
-            pool_idle_timeout: Connection pool idle timeout (seconds).
-            pool_max_idle_per_host: Max idle connections per host.
-            pool_max_size: Max total connections in pool.
-            http1_only: Enable HTTP/1.1 only.
-            http2_only: Enable HTTP/2 only.
-            https_only: Enable HTTPS only.
-            http2_max_retry_count: Max HTTP/2 retry count.
-            verify: Verify SSL or specify CA path.
-            identity: Represents a private key and X509 cert as a client certificate.
-            keylog: Key logging policy (environment or file).
-            tls_info: Return TLS info.
-            min_tls_version: Minimum TLS version.
-            max_tls_version: Maximum TLS version.
-            no_proxy: Disable proxy.
-            proxies: Proxy server list.
-            local_address: Local bind address.
-            interface: Local network interface.
-            gzip: Enable gzip decompression.
-            brotli: Enable brotli decompression.
-            deflate: Enable deflate decompression.
-            zstd: Enable zstd decompression.
-
         # Examples
 
         ```python
@@ -72,13 +200,14 @@ class Client:
         import rnet
 
         client = rnet.blocking.Client(
-            user_agent="my-app/0.0.1",
+            user_agent="Mozilla/5.0",
             timeout=10,
         )
         response = client.get('https://httpbin.org/get')
         print(response.text())
         ```
         """
+        ...
 
     def request(
         self,
@@ -93,17 +222,13 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.request(Method.GET, "https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.request(Method.GET, "https://httpbin.org/anything")
         ```
         """
+        ...
 
     def websocket(self, url: str, **kwargs: Unpack[WebSocketRequest]) -> "WebSocket":
         r"""
@@ -113,19 +238,16 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
-
-        async def main():
-            client = rnet.blocking.Client()
-            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())
+        client = rnet.blocking.Client()
+        ws = client.websocket("wss://echo.websocket.org")
+        ws.send(rnet.Message.from_text("Hello, WebSocket!"))
+        message = ws.recv()
+        print("Received:", message.data)
+        ws.close()
         ```
         """
+        ...
 
     def trace(
         self,
@@ -139,17 +261,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.trace("https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.trace("https://httpbin.org/anything")
+        print(response.text())
         ```
         """
+        ...
 
     def options(
         self,
@@ -163,17 +282,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.options("https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.options("https://httpbin.org/anything")
+        print(response.text())
         ```
         """
+        ...
 
     def head(
         self,
@@ -187,17 +303,15 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.head("https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        def main():
+        client = rnet.blocking.Client()
+        response = client.head("https://httpbin.org/anything")
+        print(response.text())
         ```
         """
+        ...
 
     def delete(
         self,
@@ -211,17 +325,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.delete("https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.delete("https://httpbin.org/anything")
+        print(response.text())
         ```
         """
+        ...
 
     def patch(
         self,
@@ -235,17 +346,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.patch("https://httpbin.org/anything", json={"key": "value"})
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.patch("https://httpbin.org/anything", json={"key": "value"})
+        print(response.text())
         ```
         """
+        ...
 
     def put(
         self,
@@ -259,17 +367,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.put("https://httpbin.org/anything", json={"key": "value"})
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.put("https://httpbin.org/anything", json={"key": "value"})
+        print(response.text())
         ```
         """
+        ...
 
     def post(
         self,
@@ -283,17 +388,14 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.post("https://httpbin.org/anything", json={"key": "value"})
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.post("https://httpbin.org/anything", json={"key": "value"})
+        print(response.text())
         ```
         """
+        ...
 
     def get(
         self,
@@ -307,161 +409,11 @@ class Client:
 
         ```python
         import rnet
-        import asyncio
         from rnet import Method
 
-        async def main():
-            client = rnet.blocking.Client()
-            response = client.get("https://httpbin.org/anything")
-            print(response.text())
-
-        asyncio.run(main())
+        client = rnet.blocking.Client()
+        response = client.get("https://httpbin.org/anything")
+        print(response.text())
         ```
         """
-
-
-class Response:
-    r"""
-    A blocking response from a request.
-    """
-
-    url: str
-    r"""
-    Returns the URL of the response.
-    """
-    status: StatusCode
-    r"""
-    Returns the status code of the response.
-    """
-    version: Version
-    r"""
-    Returns the HTTP version of the response.
-    """
-    headers: HeaderMap
-    r"""
-    Returns the headers of the response.
-    """
-    cookies: List[Cookie]
-    r"""
-    Returns the cookies of the response.
-    """
-    content_length: int
-    r"""
-    Returns the content length of the response.
-    """
-    remote_addr: Optional[SocketAddr]
-    r"""
-    Returns the remote address of the response.
-    """
-    local_addr: Optional[SocketAddr]
-    r"""
-    Returns the local address of the response.
-    """
-    encoding: str
-    r"""
-    Encoding to decode with when accessing text.
-    """
-
-    def __enter__(self) -> "Response": ...
-    def __exit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> None: ...
-    def peer_certificate(self) -> Optional[bytes]:
-        r"""
-        Returns the TLS peer certificate of the response.
-        """
-
-    def text(self) -> str:
-        r"""
-        Returns the text content of the response.
-        """
-
-    def text_with_charset(self, encoding: str) -> str:
-        r"""
-        Returns the text content of the response with a specific charset.
-
-        # Arguments
-
-        * `encoding` - The default encoding to use if the charset is not specified.
-        """
-
-    def json(self) -> Any:
-        r"""
-        Returns the JSON content of the response.
-        """
-
-    def bytes(self) -> bytes:
-        r"""
-        Returns the bytes content of the response.
-        """
-
-    def stream(self) -> Streamer:
-        r"""
-        Convert the response into a `Stream` of `Bytes` from the body.
-        """
-
-    def close(self) -> None:
-        r"""
-        Closes the response connection.
-        """
-
-
-class WebSocket:
-    r"""
-    A blocking WebSocket response.
-    """
-
-    status: StatusCode
-    r"""
-    Returns the status code of the response.
-    """
-    version: Version
-    r"""
-    Returns the HTTP version of the response.
-    """
-    headers: HeaderMap
-    r"""
-    Returns the headers of the response.
-    """
-    cookies: List[Cookie]
-    r"""
-    Returns the cookies of the response.
-    """
-    remote_addr: Optional[SocketAddr]
-    r"""
-    Returns the remote address of the response.
-    """
-    protocol: Optional[str]
-    r"""
-    Returns the WebSocket protocol.
-    """
-
-    def __iter__(self) -> "WebSocket": ...
-    def __next__(self) -> Message: ...
-    def __enter__(self) -> "WebSocket": ...
-    def __exit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> None: ...
-    def recv(self) -> Optional[Message]:
-        r"""
-        Receives a message from the WebSocket.
-        """
-
-    def send(self, message: Message) -> None:
-        r"""
-        Sends a message to the WebSocket.
-
-        # Arguments
-
-        * `message` - The message to send.
-        """
-
-    def close(
-        self,
-        code: Optional[int] = None,
-        reason: Optional[str] = None,
-    ) -> None:
-        r"""
-        Closes the WebSocket connection.
-
-        # Arguments
-
-        * `code` - An optional close code.
-        * `reason` - An optional reason for closing.
-        """
+        ...

rnet/cookie.py

@@ -10,6 +10,8 @@ import datetime
 from enum import Enum, auto
 from typing import List, Optional
 
+__all__ = ["SameSite", "Cookie", "Jar"]
+
 
 class SameSite(Enum):
     r"""
@@ -68,20 +70,21 @@ class Cookie:
     """
 
     def __init__(
-        cls,
+        self,
         name: str,
         value: str,
         domain: str | None = None,
         path: str | None = None,
         max_age: datetime.timedelta | None = None,
         expires: datetime.datetime | None = None,
-        http_only: bool = False,
-        secure: bool = False,
+        http_only: bool | None = None,
+        secure: bool | None = None,
         same_site: SameSite | None = None,
-    ) -> "Cookie":
+    ) -> None:
         r"""
         Create a new cookie.
         """
+        ...
 
     def __str__(self) -> str: ...
 
@@ -94,37 +97,44 @@ class Jar:
     to automatically handle cookies during HTTP requests and responses.
     """
 
-    def __init__(cls) -> "Jar":
+    def __init__(self) -> None:
         r"""
         Create a new cookie jar.
         """
+        ...
 
     def get(self, name: str, url: str) -> Optional[Cookie]:
         r"""
         Get a cookie by name and URL.
         """
+        ...
 
     def get_all(self) -> List[Cookie]:
         r"""
         Get all cookies.
         """
+        ...
 
-    def add(self, cookie: Cookie, url: str) -> None:
+    def add_cookie(self, cookie: Cookie, url: str) -> None:
         r"""
         Add a cookie to this jar.
         """
+        ...
 
     def add_cookie_str(self, cookie: str, url: str) -> None:
         r"""
         Add a cookie str to this jar.
         """
+        ...
 
     def remove(self, name: str, url: str) -> None:
         r"""
         Remove a cookie from this jar by name and URL.
         """
+        ...
 
     def clear(self) -> None:
         r"""
         Clear all cookies in this jar.
         """
+        ...