httpr 0.1.17__cp39-abi3-win_amd64.whl

httpr/__init__.py

@@ -0,0 +1,870 @@
+"""
+httpr - Blazing fast HTTP client for Python, built in Rust.
+
+httpr is a high-performance HTTP client that can be used as a drop-in replacement
+for `httpx` and `requests` in most cases.
+
+Example:
+    Simple GET request:
+
+    ```python
+    import httpr
+
+    response = httpr.get("https://httpbin.org/get")
+    print(response.json())
+    ```
+
+    Using a client for connection pooling:
+
+    ```python
+    import httpr
+
+    with httpr.Client() as client:
+        response = client.get("https://httpbin.org/get")
+        print(response.status_code)
+    ```
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from functools import partial
+from typing import TYPE_CHECKING, Any, TypedDict
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import Unpack
+else:
+    from typing import Unpack
+
+
+from .httpr import RClient
+
+if TYPE_CHECKING:
+    from .httpr import ClientRequestParams, HttpMethod, RequestParams, Response
+else:
+
+    class _Unpack:
+        @staticmethod
+        def __getitem__(*args, **kwargs):
+            pass
+
+    Unpack = _Unpack()
+    RequestParams = ClientRequestParams = TypedDict
+
+
+class Client(RClient):
+    """
+    A synchronous HTTP client with connection pooling.
+
+    The Client class provides a high-level interface for making HTTP requests.
+    It supports connection pooling, automatic cookie handling, and various
+    authentication methods.
+
+    Example:
+        Basic usage:
+
+        ```python
+        import httpr
+
+        # Using context manager (recommended)
+        with httpr.Client() as client:
+            response = client.get("https://httpbin.org/get")
+            print(response.json())
+
+        # Or manually
+        client = httpr.Client()
+        response = client.get("https://httpbin.org/get")
+        client.close()
+        ```
+
+        With configuration:
+
+        ```python
+        import httpr
+
+        client = httpr.Client(
+            auth_bearer="your-api-token",
+            headers={"User-Agent": "my-app/1.0"},
+            timeout=30,
+        )
+        ```
+
+    Attributes:
+        headers: Default headers sent with all requests. Excludes Cookie header.
+        cookies: Default cookies sent with all requests.
+        auth: Basic auth credentials as (username, password) tuple.
+        params: Default query parameters added to all requests.
+        timeout: Default timeout in seconds.
+        proxy: Proxy URL for requests.
+    """
+
+    def __init__(
+        self,
+        auth: tuple[str, str | None] | None = None,
+        auth_bearer: str | None = None,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        cookie_store: bool | None = True,
+        referer: bool | None = True,
+        proxy: str | None = None,
+        timeout: float | None = 30,
+        follow_redirects: bool | None = True,
+        max_redirects: int | None = 20,
+        verify: bool | None = True,
+        ca_cert_file: str | None = None,
+        client_pem: str | None = None,
+        https_only: bool | None = False,
+        http2_only: bool | None = False,
+    ):
+        """
+        Initialize an HTTP client.
+
+        Args:
+            auth: Basic auth credentials as (username, password). Password can be None.
+            auth_bearer: Bearer token for Authorization header.
+            params: Default query parameters to include in all requests.
+            headers: Default headers to send with all requests.
+            cookies: Default cookies to send with all requests.
+            cookie_store: Enable persistent cookie store. Cookies from responses will be
+                preserved and included in subsequent requests. Default is True.
+            referer: Automatically set Referer header. Default is True.
+            proxy: Proxy URL (e.g., "http://proxy:8080" or "socks5://127.0.0.1:1080").
+                Falls back to HTTPR_PROXY environment variable.
+            timeout: Request timeout in seconds. Default is 30.
+            follow_redirects: Follow HTTP redirects. Default is True.
+            max_redirects: Maximum redirects to follow. Default is 20.
+            verify: Verify SSL certificates. Default is True.
+            ca_cert_file: Path to CA certificate bundle (PEM format).
+            client_pem: Path to client certificate for mTLS (PEM format).
+            https_only: Only allow HTTPS requests. Default is False.
+            http2_only: Use HTTP/2 only (False uses HTTP/1.1). Default is False.
+
+        Example:
+            ```python
+            import httpr
+
+            # Simple client
+            client = httpr.Client()
+
+            # Client with authentication
+            client = httpr.Client(
+                auth=("username", "password"),
+                timeout=60,
+            )
+
+            # Client with bearer token
+            client = httpr.Client(
+                auth_bearer="your-api-token",
+                headers={"Accept": "application/json"},
+            )
+
+            # Client with proxy
+            client = httpr.Client(proxy="http://proxy.example.com:8080")
+
+            # Client with mTLS
+            client = httpr.Client(
+                client_pem="/path/to/client.pem",
+                ca_cert_file="/path/to/ca.pem",
+            )
+            ```
+        """
+        super().__init__()
+
+    def __enter__(self) -> Client:
+        """Enter context manager."""
+        return self
+
+    def __exit__(self, *args):
+        """Exit context manager and close client."""
+        del self
+
+    def close(self) -> None:
+        """
+        Close the client and release resources.
+
+        Example:
+            ```python
+            client = httpr.Client()
+            try:
+                response = client.get("https://example.com")
+            finally:
+                client.close()
+            ```
+        """
+        del self
+
+    def request(
+        self,
+        method: HttpMethod,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS).
+            url: Request URL.
+            **kwargs: Request parameters (see below).
+
+        Keyword Args:
+            params (dict[str, str] | None): Query parameters to append to URL.
+            headers (dict[str, str] | None): Request headers (merged with client defaults).
+            cookies (dict[str, str] | None): Request cookies (merged with client defaults).
+            auth (tuple[str, str | None] | None): Basic auth credentials (overrides client default).
+            auth_bearer (str | None): Bearer token (overrides client default).
+            timeout (float | None): Request timeout in seconds (overrides client default).
+            content (bytes | None): Raw bytes for request body.
+            data (dict[str, Any] | None): Form data for request body (application/x-www-form-urlencoded).
+            json (Any | None): JSON data for request body (application/json).
+            files (dict[str, str] | None): Files for multipart upload (dict mapping field names to file paths).
+
+        Returns:
+            Response object with status, headers, and body.
+
+        Raises:
+            ValueError: If method is not a valid HTTP method.
+            Exception: If request fails (timeout, connection error, etc.).
+
+        Example:
+            ```python
+            response = client.request("GET", "https://httpbin.org/get")
+            response = client.request("POST", "https://httpbin.org/post", json={"key": "value"})
+            ```
+
+        Note:
+            Only one of `content`, `data`, `json`, or `files` can be specified per request.
+        """
+        if method not in ["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+        if "params" in kwargs and kwargs["params"] is not None:
+            kwargs["params"] = {k: str(v) for k, v in kwargs["params"].items()}
+
+        return super().request(method=method, url=url, **kwargs)
+
+    def get(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a GET request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters (params, headers, cookies, auth, auth_bearer, timeout).
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = client.get(
+                "https://httpbin.org/get",
+                params={"key": "value"},
+                headers={"Accept": "application/json"},
+            )
+            print(response.json())
+            ```
+        """
+        return self.request(method="GET", url=url, **kwargs)
+
+    def head(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a HEAD request.
+
+        Returns only headers, no response body.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters (params, headers, cookies, auth, auth_bearer, timeout).
+
+        Returns:
+            Response object (body will be empty).
+
+        Example:
+            ```python
+            response = client.head("https://httpbin.org/get")
+            print(response.headers["content-length"])
+            ```
+        """
+        return self.request(method="HEAD", url=url, **kwargs)
+
+    def options(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make an OPTIONS request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters (params, headers, cookies, auth, auth_bearer, timeout).
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = client.options("https://httpbin.org/get")
+            print(response.headers.get("allow"))
+            ```
+        """
+        return self.request(method="OPTIONS", url=url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a DELETE request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters (params, headers, cookies, auth, auth_bearer, timeout).
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = client.delete("https://httpbin.org/delete")
+            print(response.status_code)
+            ```
+        """
+        return self.request(method="DELETE", url=url, **kwargs)
+
+    def post(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a POST request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Keyword Args:
+            params (dict[str, str] | None): Query parameters.
+            headers (dict[str, str] | None): Request headers.
+            cookies (dict[str, str] | None): Request cookies.
+            auth (tuple[str, str | None] | None): Basic auth credentials.
+            auth_bearer (str | None): Bearer token.
+            timeout (float | None): Request timeout.
+            content (bytes | None): Raw bytes body.
+            data (dict[str, Any] | None): Form-encoded body.
+            json (Any | None): JSON body.
+            files (dict[str, str] | None): Multipart file uploads.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            # JSON body
+            response = client.post(
+                "https://httpbin.org/post",
+                json={"name": "httpr", "fast": True},
+            )
+
+            # Form data
+            response = client.post(
+                "https://httpbin.org/post",
+                data={"username": "user", "password": "pass"},
+            )
+
+            # File upload
+            response = client.post(
+                "https://httpbin.org/post",
+                files={"document": "/path/to/file.pdf"},
+            )
+            ```
+        """
+        return self.request(method="POST", url=url, **kwargs)
+
+    def put(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a PUT request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = client.put(
+                "https://httpbin.org/put",
+                json={"key": "updated_value"},
+            )
+            ```
+        """
+        return self.request(method="PUT", url=url, **kwargs)
+
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Make a PATCH request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = client.patch(
+                "https://httpbin.org/patch",
+                json={"field": "new_value"},
+            )
+            ```
+        """
+        return self.request(method="PATCH", url=url, **kwargs)
+
+
+class AsyncClient(Client):
+    """
+    An asynchronous HTTP client for use with asyncio.
+
+    AsyncClient wraps the synchronous Client using asyncio.run_in_executor(),
+    providing an async interface while leveraging the Rust implementation's
+    performance.
+
+    Example:
+        Basic usage:
+
+        ```python
+        import asyncio
+        import httpr
+
+        async def main():
+            async with httpr.AsyncClient() as client:
+                response = await client.get("https://httpbin.org/get")
+                print(response.json())
+
+        asyncio.run(main())
+        ```
+
+        Concurrent requests:
+
+        ```python
+        import asyncio
+        import httpr
+
+        async def main():
+            async with httpr.AsyncClient() as client:
+                tasks = [
+                    client.get("https://httpbin.org/get"),
+                    client.get("https://httpbin.org/ip"),
+                ]
+                responses = await asyncio.gather(*tasks)
+                for response in responses:
+                    print(response.json())
+
+        asyncio.run(main())
+        ```
+
+    Note:
+        AsyncClient runs synchronous Rust code in a thread executor.
+        It provides concurrency benefits for I/O-bound tasks but is not
+        native async I/O.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize an async HTTP client.
+
+        Accepts the same parameters as Client.
+        """
+        super().__init__(*args, **kwargs)
+
+    async def __aenter__(self) -> AsyncClient:
+        """Enter async context manager."""
+        return self
+
+    async def __aexit__(self, *args):
+        """Exit async context manager and close client."""
+        del self
+
+    async def aclose(self):
+        """
+        Close the async client.
+
+        Example:
+            ```python
+            client = httpr.AsyncClient()
+            try:
+                response = await client.get("https://example.com")
+            finally:
+                await client.aclose()
+            ```
+        """
+        del self
+        return
+
+    async def _run_sync_asyncio(self, fn, *args, **kwargs):
+        """Run a synchronous function in an executor."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, partial(fn, *args, **kwargs))
+
+    async def request(  # type: ignore[override]
+        self,
+        method: HttpMethod,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async HTTP request.
+
+        Args:
+            method: HTTP method.
+            url: Request URL.
+            **kwargs: Request parameters.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = await client.request("GET", "https://httpbin.org/get")
+            ```
+        """
+        if method not in ["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+        if "params" in kwargs and kwargs["params"] is not None:
+            kwargs["params"] = {k: str(v) for k, v in kwargs["params"].items()}
+
+        return await self._run_sync_asyncio(super().request, method=method, url=url, **kwargs)
+
+    async def get(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async GET request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = await client.get("https://httpbin.org/get")
+            ```
+        """
+        return await self.request(method="GET", url=url, **kwargs)
+
+    async def head(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async HEAD request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters.
+
+        Returns:
+            Response object.
+        """
+        return await self.request(method="HEAD", url=url, **kwargs)
+
+    async def options(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async OPTIONS request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters.
+
+        Returns:
+            Response object.
+        """
+        return await self.request(method="OPTIONS", url=url, **kwargs)
+
+    async def delete(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async DELETE request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters.
+
+        Returns:
+            Response object.
+        """
+        return await self.request(method="DELETE", url=url, **kwargs)
+
+    async def post(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async POST request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Returns:
+            Response object.
+
+        Example:
+            ```python
+            response = await client.post(
+                "https://httpbin.org/post",
+                json={"key": "value"},
+            )
+            ```
+        """
+        return await self.request(method="POST", url=url, **kwargs)
+
+    async def put(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async PUT request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Returns:
+            Response object.
+        """
+        return await self.request(method="PUT", url=url, **kwargs)
+
+    async def patch(  # type: ignore[override]
+        self,
+        url: str,
+        **kwargs: Unpack[RequestParams],
+    ) -> Response:
+        """
+        Make an async PATCH request.
+
+        Args:
+            url: Request URL.
+            **kwargs: Request parameters including body options.
+
+        Returns:
+            Response object.
+        """
+        return await self.request(method="PATCH", url=url, **kwargs)
+
+
+def request(
+    method: HttpMethod,
+    url: str,
+    verify: bool | None = True,
+    ca_cert_file: str | None = None,
+    client_pem: str | None = None,
+    **kwargs: Unpack[RequestParams],
+) -> Response:
+    """
+    Make an HTTP request using a temporary client.
+
+    This is a convenience function for one-off requests. For multiple requests,
+    use a Client instance for better performance (connection pooling).
+
+    Args:
+        method: HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS).
+        url: Request URL.
+        verify: Verify SSL certificates. Default is True.
+        ca_cert_file: Path to CA certificate bundle.
+        client_pem: Path to client certificate for mTLS.
+        **kwargs: Additional request parameters.
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.request("GET", "https://httpbin.org/get")
+        response = httpr.request("POST", "https://httpbin.org/post", json={"key": "value"})
+        ```
+    """
+    with Client(
+        verify=verify,
+        ca_cert_file=ca_cert_file,
+        client_pem=client_pem,
+    ) as client:
+        return client.request(method, url, **kwargs)
+
+
+def get(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a GET request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters (params, headers, cookies, auth, timeout, etc.).
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.get("https://httpbin.org/get", params={"key": "value"})
+        print(response.json())
+        ```
+    """
+    return request(method="GET", url=url, **kwargs)
+
+
+def head(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a HEAD request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters.
+
+    Returns:
+        Response object (body will be empty).
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.head("https://httpbin.org/get")
+        print(response.headers)
+        ```
+    """
+    return request(method="HEAD", url=url, **kwargs)
+
+
+def options(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make an OPTIONS request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters.
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.options("https://httpbin.org/get")
+        ```
+    """
+    return request(method="OPTIONS", url=url, **kwargs)
+
+
+def delete(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a DELETE request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters.
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.delete("https://httpbin.org/delete")
+        ```
+    """
+    return request(method="DELETE", url=url, **kwargs)
+
+
+def post(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a POST request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters (json, data, content, files, etc.).
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        # JSON body
+        response = httpr.post("https://httpbin.org/post", json={"key": "value"})
+
+        # Form data
+        response = httpr.post("https://httpbin.org/post", data={"field": "value"})
+        ```
+    """
+    return request(method="POST", url=url, **kwargs)
+
+
+def put(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a PUT request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters.
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.put("https://httpbin.org/put", json={"key": "value"})
+        ```
+    """
+    return request(method="PUT", url=url, **kwargs)
+
+
+def patch(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response:
+    """
+    Make a PATCH request using a temporary client.
+
+    Args:
+        url: Request URL.
+        **kwargs: Request parameters.
+
+    Returns:
+        Response object.
+
+    Example:
+        ```python
+        import httpr
+
+        response = httpr.patch("https://httpbin.org/patch", json={"field": "new_value"})
+        ```
+    """
+    return request(method="PATCH", url=url, **kwargs)
+
+
+__all__ = [
+    "Client",
+    "AsyncClient",
+    "request",
+    "get",
+    "head",
+    "options",
+    "delete",
+    "post",
+    "put",
+    "patch",
+]

httpr/httpr.pyi

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Literal, TypedDict
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import Unpack
+else:
+    from typing import Unpack
+
+HttpMethod = Literal["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]
+
+class RequestParams(TypedDict, total=False):
+    auth: tuple[str, str | None] | None
+    auth_bearer: str | None
+    params: dict[str, str] | None
+    headers: dict[str, str] | None
+    cookies: dict[str, str] | None
+    timeout: float | None
+    content: bytes | None
+    data: dict[str, Any] | None
+    json: Any | None
+    files: dict[str, str] | None
+
+class ClientRequestParams(RequestParams):
+    verify: bool | None
+    ca_cert_file: str | None
+    client_pem: str | None
+
+class Response:
+    @property
+    def content(self) -> bytes: ...
+    @property
+    def cookies(self) -> dict[str, str]: ...
+    @property
+    def headers(self) -> dict[str, str]: ...
+    @property
+    def status_code(self) -> int: ...
+    @property
+    def url(self) -> str: ...
+    @property
+    def encoding(self) -> str: ...
+    @property
+    def text(self) -> str: ...
+    def json(self) -> Any: ...
+    @property
+    def text_markdown(self) -> str: ...
+    @property
+    def text_plain(self) -> str: ...
+    @property
+    def text_rich(self) -> str: ...
+
+class RClient:
+    def __init__(
+        self,
+        auth: tuple[str, str | None] | None = None,
+        auth_bearer: str | None = None,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        timeout: float | None = None,
+        cookie_store: bool | None = True,
+        referer: bool | None = True,
+        proxy: str | None = None,
+        follow_redirects: bool | None = True,
+        max_redirects: int | None = 20,
+        verify: bool | None = True,
+        ca_cert_file: str | None = None,
+        client_pem: str | None = None,
+        https_only: bool | None = False,
+        http2_only: bool | None = False,
+    ): ...
+    @property
+    def headers(self) -> dict[str, str]: ...
+    @headers.setter
+    def headers(self, headers: dict[str, str]) -> None: ...
+    @property
+    def cookies(self) -> dict[str, str]: ...
+    @cookies.setter
+    def cookies(self, cookies: dict[str, str]) -> None: ...
+    @property
+    def proxy(self) -> str | None: ...
+    @proxy.setter
+    def proxy(self, proxy: str) -> None: ...
+    def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def get(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def head(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def options(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def post(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def put(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+
+def request(method: HttpMethod, url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def get(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def head(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def options(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def delete(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def post(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def put(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def patch(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...

httpr-0.1.17.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: httpr
+Version: 0.1.17
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: certifi ; extra == 'dev'
+Requires-Dist: pytest>=8.1.1 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25.3 ; extra == 'dev'
+Requires-Dist: pytest-httpbin>=2.1.0 ; extra == 'dev'
+Requires-Dist: typing-extensions ; python_full_version < '3.12' and extra == 'dev'
+Requires-Dist: mypy>=1.14.1 ; extra == 'dev'
+Requires-Dist: ruff>=0.9.2 ; extra == 'dev'
+Requires-Dist: maturin ; extra == 'dev'
+Requires-Dist: trustme ; extra == 'dev'
+Requires-Dist: mkdocs-material[imaging] ; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.27.0 ; extra == 'docs'
+Requires-Dist: mkdocs-gen-files ; extra == 'docs'
+Requires-Dist: mkdocs-literate-nav ; extra == 'docs'
+Requires-Dist: httpr[dev] ; extra == 'scratch'
+Requires-Dist: matplotlib ; extra == 'scratch'
+Requires-Dist: pandas ; extra == 'scratch'
+Requires-Dist: jupyter ; extra == 'scratch'
+Requires-Dist: ipykernel ; extra == 'scratch'
+Requires-Dist: httpx ; extra == 'scratch'
+Requires-Dist: gunicorn ; extra == 'scratch'
+Requires-Dist: uvicorn ; extra == 'scratch'
+Requires-Dist: trustme ; extra == 'scratch'
+Requires-Dist: starlette ; extra == 'scratch'
+Requires-Dist: fastapi ; extra == 'scratch'
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: scratch
+License-File: LICENSE
+Summary: Fast HTTP client for Python
+Keywords: python,request
+Author: thomasht86
+License: MIT License
+Requires-Python: >=3.9

httpr-0.1.17.dist-info/RECORD

@@ -0,0 +1,8 @@
+httpr-0.1.17.dist-info/METADATA,sha256=W9D8erBK9zt9tqon55skX41ATkiwcseTJG9idOwGbsk,2129
+httpr-0.1.17.dist-info/WHEEL,sha256=W8IbRrW6aFuwgkpVWKTtkIq8XwJIIpO5tHf4goK_jm8,95
+httpr-0.1.17.dist-info/licenses/LICENSE,sha256=O15TIxUAXq6sSpPu0K3CJu_dT5ZzCgIk7hQtZsf0lEk,1084
+httpr/__init__.py,sha256=TQtmQx9A8g9mEHMghynFab2XC-bjmu1fK1FMjrYNJ18,25174
+httpr/httpr.pyd,sha256=k87zTK5grPYfqo18BiJEvdTW8vfwhw2-NybbI_tFwss,4539904
+httpr/httpr.pyi,sha256=VbROFo3ZXTacg2Fe0kvQWZ0RXXrAK08F4ivUL0cvGtY,3830
+httpr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpr-0.1.17.dist-info/RECORD,,

httpr-0.1.17.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64

httpr-0.1.17.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 deedy5
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.