httpr 0.2.5__cp313-cp313t-musllinux_1_2_i686.whl → 0.3.2__cp313-cp313t-musllinux_1_2_i686.whl

httpr/__init__.py

@@ -117,6 +117,7 @@ class Client(RClient):
         verify: bool | None = True,
         ca_cert_file: str | None = None,
         client_pem: str | None = None,
+        client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
     ):
@@ -140,6 +141,8 @@ class Client(RClient):
             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).
+            client_pem_data: Client certificate and key as bytes for mTLS (PEM format).
+                Use this instead of client_pem when you have the certificate in memory.
             https_only: Only allow HTTPS requests. Default is False.
             http2_only: Use HTTP/2 only (False uses HTTP/1.1). Default is False.
 
@@ -165,11 +168,18 @@ class Client(RClient):
             # Client with proxy
             client = httpr.Client(proxy="http://proxy.example.com:8080")
 
-            # Client with mTLS
+            # Client with mTLS using file path
             client = httpr.Client(
                 client_pem="/path/to/client.pem",
                 ca_cert_file="/path/to/ca.pem",
             )
+
+            # Client with mTLS using direct certificate data
+            cert_data = b"-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----"
+            client = httpr.Client(
+                client_pem_data=cert_data,
+                ca_cert_file="/path/to/ca.pem",
+            )
             ```
         """
         super().__init__()
@@ -212,16 +222,16 @@ class Client(RClient):
             **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).
+            params (Optional[dict[str, str]]): Query parameters to append to URL.
+            headers (Optional[dict[str, str]]): Request headers (merged with client defaults).
+            cookies (Optional[dict[str, str]]): Request cookies (merged with client defaults).
+            auth (Optional[tuple[str, Optional[str]]]): Basic auth credentials (overrides client default).
+            auth_bearer (Optional[str]): Bearer token (overrides client default).
+            timeout (Optional[float]): Request timeout in seconds (overrides client default).
+            content (Optional[bytes]): Raw bytes for request body.
+            data (Optional[dict[str, Any]]): Form data for request body (application/x-www-form-urlencoded).
+            json (Optional[Any]): JSON data for request body (application/json).
+            files (Optional[dict[str, str]]): Files for multipart upload (dict mapping field names to file paths).
 
         Returns:
             Response object with status, headers, and body.
@@ -337,16 +347,16 @@ class Client(RClient):
             **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.
+            params (Optional[dict[str, str]]): Query parameters.
+            headers (Optional[dict[str, str]]): Request headers.
+            cookies (Optional[dict[str, str]]): Request cookies.
+            auth (Optional[tuple[str, Optional[str]]]): Basic auth credentials.
+            auth_bearer (Optional[str]): Bearer token.
+            timeout (Optional[float]): Request timeout.
+            content (Optional[bytes]): Raw bytes body.
+            data (Optional[dict[str, Any]]): Form-encoded body.
+            json (Optional[Any]): JSON body.
+            files (Optional[dict[str, str]]): Multipart file uploads.
 
         Returns:
             Response object.
@@ -787,6 +797,7 @@ def request(
     verify: bool | None = True,
     ca_cert_file: str | None = None,
     client_pem: str | None = None,
+    client_pem_data: bytes | None = None,
     **kwargs: Unpack[RequestParams],
 ) -> Response:
     """
@@ -801,6 +812,7 @@ def request(
         verify: Verify SSL certificates. Default is True.
         ca_cert_file: Path to CA certificate bundle.
         client_pem: Path to client certificate for mTLS.
+        client_pem_data: Client certificate and key as bytes for mTLS.
         **kwargs: Additional request parameters.
 
     Returns:
@@ -818,6 +830,7 @@ def request(
         verify=verify,
         ca_cert_file=ca_cert_file,
         client_pem=client_pem,
+        client_pem_data=client_pem_data,
     ) as client:
         return client.request(method, url, **kwargs)
 

httpr/httpr.pyi

@@ -28,6 +28,7 @@ class ClientRequestParams(RequestParams):
     verify: bool | None
     ca_cert_file: str | None
     client_pem: str | None
+    client_pem_data: bytes | None
 
 class CaseInsensitiveHeaderMap:
     """
@@ -286,6 +287,7 @@ class RClient:
         verify: bool | None = True,
         ca_cert_file: str | None = None,
         client_pem: str | None = None,
+        client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
     ): ...
@@ -374,6 +376,7 @@ class Client(RClient):
         verify: bool | None = True,
         ca_cert_file: str | None = None,
         client_pem: str | None = None,
+        client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
     ) -> None:
@@ -395,6 +398,7 @@ class Client(RClient):
             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).
+            client_pem_data: Client certificate and key as bytes for mTLS (PEM format).
             https_only: Only allow HTTPS requests. Default is False.
             http2_only: Use HTTP/2 only. Default is False.
         """
@@ -472,6 +476,7 @@ class AsyncClient(Client):
         verify: bool | None = True,
         ca_cert_file: str | None = None,
         client_pem: str | None = None,
+        client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
     ) -> None:

httpr-0.3.2.dist-info/METADATA

@@ -0,0 +1,481 @@
+Metadata-Version: 2.4
+Name: httpr
+Version: 0.3.2
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: matplotlib ; extra == 'benchmark'
+Requires-Dist: pandas ; extra == 'benchmark'
+Requires-Dist: starlette ; extra == 'benchmark'
+Requires-Dist: uvicorn ; extra == 'benchmark'
+Requires-Dist: requests ; extra == 'benchmark'
+Requires-Dist: httpx ; extra == 'benchmark'
+Requires-Dist: tls-client ; extra == 'benchmark'
+Requires-Dist: curl-cffi ; extra == 'benchmark'
+Requires-Dist: pycurl ; extra == 'benchmark'
+Requires-Dist: typing-extensions ; extra == 'benchmark'
+Requires-Dist: aiohttp ; extra == 'benchmark'
+Requires-Dist: cbor2 ; extra == 'benchmark'
+Requires-Dist: jupyter ; extra == 'benchmark'
+Requires-Dist: ipykernel ; extra == 'benchmark'
+Requires-Dist: gunicorn ; extra == 'benchmark'
+Requires-Dist: fastapi ; extra == 'benchmark'
+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-benchmark>=5.1.0 ; 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: cbor2 ; extra == 'dev'
+Requires-Dist: go-task-bin ; extra == 'dev'
+Requires-Dist: pre-commit ; 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: mkdocs-llmstxt ; extra == 'docs'
+Provides-Extra: benchmark
+Provides-Extra: dev
+Provides-Extra: docs
+License-File: LICENSE
+Summary: Fast HTTP client for Python
+Keywords: python,request
+Author: thomasht86
+License: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# httpr
+
+**Blazing fast http-client** for Python in Rust 🦀 that can be used as drop-in replacement for `httpx` and `requests` in most cases.
+
+- **Fast**: `httpr` is built on top of `reqwests`, which is a blazing fast http client in Rust. Check out the [benchmark](#benchmark).
+- **Both async and sync**: `httpr` provides both a sync and async client.
+- **Lightweight**: `httpr` is a lightweight http client with zero python-dependencies.
+- **Async**: first-class async support.
+- **Streaming**: supports streaming responses for efficient memory usage with large payloads.
+- **http2**: `httpr` supports HTTP/2.
+- **mTLS**: `httpr` supports mTLS.
+
+## Not implemented yet
+
+- **Fine-grained error handling**: Fine-grained error handling is not implemented yet.
+
+## Documentation
+
+📖 **Full documentation**: [thomasht86.github.io/httpr](https://thomasht86.github.io/httpr)
+
+🤖 **LLM-friendly docs**: [llms.txt](https://thomasht86.github.io/httpr/llms.txt) | [llms-full.txt](https://thomasht86.github.io/httpr/llms-full.txt)
+
+## Table of Contents
+
+- [httpr](#httpr)
+  - [Not implemented yet](#not-implemented-yet)
+  - [Documentation](#documentation)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+    - [Install with uv](#install-with-uv)
+    - [Install from PyPI](#install-from-pypi)
+  - [Benchmark](#benchmark)
+  - [Usage](#usage)
+    - [I. Client](#i-client)
+      - [Client methods](#client-methods)
+      - [Response object](#response-object)
+      - [Streaming responses](#streaming-responses)
+      - [Examples](#examples)
+    - [II. AsyncClient](#ii-asyncclient)
+  - [Precompiled wheels](#precompiled-wheels)
+  - [CI](#ci)
+  - [Acknowledgements](#acknowledgements)
+
+## Installation
+
+### Install with uv
+
+```python
+uv add httpr
+```
+
+or
+
+```python
+uv pip install httpr
+```
+
+### Install from PyPI
+
+```python
+pip install -U httpr
+```
+
+## Benchmark
+
+![](https://thomasht86.github.io/httpr/benchmark.jpg)
+
+## Usage
+
+### I. Client
+
+```python
+class Client:
+    """Initializes an HTTP client.
+
+    Args:
+        auth (tuple[str, str| None] | None): Username and password for basic authentication. Default is None.
+        auth_bearer (str | None): Bearer token for authentication. Default is None.
+        params (dict[str, str] | None): Default query parameters to include in all requests. Default is None.
+        headers (dict[str, str] | None): Default headers to send with requests. 
+        cookies (dict[str, str] | None): - Map of cookies to send with requests as the `Cookie` header.
+        timeout (float | None): HTTP request timeout in seconds. Default is 30.
+        cookie_store (bool | None): Enable a persistent cookie store. Received cookies will be preserved and included
+            in additional requests. Default is True.
+        referer (bool | None): Enable or disable automatic setting of the `Referer` header. Default is True.
+        proxy (str | None): Proxy URL for HTTP requests. Example: "socks5://127.0.0.1:9150". Default is None.
+        follow_redirects (bool | None): Whether to follow redirects. Default is True.
+        max_redirects (int | None): Maximum redirects to follow. Default 20. Applies if `follow_redirects` is True.
+        verify (bool | None): Verify SSL certificates. Default is True.
+        ca_cert_file (str | None): Path to CA certificate store. Default is None.
+        https_only` (bool | None): Restrict the Client to be used with HTTPS only requests. Default is `false`.
+        http2_only` (bool | None): If true - use only HTTP/2; if false - use only HTTP/1. Default is `false`.
+
+    """
+```
+
+#### Client methods
+
+The `Client` class provides a set of methods for making HTTP requests: `get`, `head`, `options`, `delete`, `post`, `put`, `patch`, each of which internally utilizes the `request()` method for execution. The parameters for these methods closely resemble those in `httpx`.
+```python
+def get(
+    url: str,
+    params: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: dict[str, str] | None = None,
+    auth: tuple[str, str| None] | None = None,
+    auth_bearer: str | None = None,
+    timeout: float | None = 30,
+):
+    """Performs a GET request to the specified URL.
+
+    Args:
+        url (str): The URL to which the request will be made.
+        params (dict[str, str] | None): A map of query parameters to append to the URL. Default is None.
+        headers (dict[str, str] | None): A map of HTTP headers to send with the request. Default is None.
+        cookies (dict[str, str] | None): - An optional map of cookies to send with requests as the `Cookie` header.
+        auth (tuple[str, str| None] | None): A tuple containing the username and an optional password
+            for basic authentication. Default is None.
+        auth_bearer (str | None): A string representing the bearer token for bearer token authentication. Default is None.
+        timeout (float | None): The timeout for the request in seconds. Default is 30.
+
+    """
+```
+```python
+def post(
+    url: str,
+    params: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: dict[str, str] | None = None,
+    content: bytes | None = None,
+    data: dict[str, Any] | None = None,
+    json: Any | None = None,
+    files: dict[str, str] | None = None,
+    auth: tuple[str, str| None] | None = None,
+    auth_bearer: str | None = None,
+    timeout: float | None = 30,
+):
+    """Performs a POST request to the specified URL.
+
+    Args:
+        url (str): The URL to which the request will be made.
+        params (dict[str, str] | None): A map of query parameters to append to the URL. Default is None.
+        headers (dict[str, str] | None): A map of HTTP headers to send with the request. Default is None.
+        cookies (dict[str, str] | None): - An optional map of cookies to send with requests as the `Cookie` header.
+        content (bytes | None): The content to send in the request body as bytes. Default is None.
+        data (dict[str, Any] | None): The form data to send in the request body. Default is None.
+        json (Any | None): A JSON serializable object to send in the request body. Default is None.
+        files (dict[str, str] | None): A map of file fields to file paths to be sent as multipart/form-data. Default is None.
+        auth (tuple[str, str| None] | None): A tuple containing the username and an optional password
+            for basic authentication. Default is None.
+        auth_bearer (str | None): A string representing the bearer token for bearer token authentication. Default is None.
+        timeout (float | None): The timeout for the request in seconds. Default is 30.
+
+    """
+```
+
+#### Response object
+
+The `Client` class returns a `Response` object that contains the following attributes and methods:
+
+```python
+resp.content
+resp.cookies
+resp.encoding
+resp.headers
+resp.json()
+resp.status_code
+resp.text
+resp.text_markdown  # html is converted to markdown text using html2text-rs
+resp.text_plain  # html is converted to plain text
+resp.text_rich  # html is converted to rich text
+resp.url
+```
+
+#### Streaming responses
+
+The `Client` class supports streaming responses for efficient memory usage when handling large payloads. Use the `stream()` context manager to iterate over response data without buffering the entire response in memory.
+
+```python
+# Stream bytes chunks
+with client.stream("GET", "https://example.com/large-file") as response:
+    print(f"Status: {response.status_code}")
+    for chunk in response.iter_bytes():
+        process(chunk)
+
+# Stream text chunks
+with client.stream("GET", "https://example.com/text") as response:
+    for text in response.iter_text():
+        print(text, end="")
+
+# Stream line by line (useful for Server-Sent Events)
+with client.stream("GET", "https://example.com/events") as response:
+    for line in response.iter_lines():
+        print(line.strip())
+
+# Read entire response (if needed after checking headers)
+with client.stream("GET", url) as response:
+    if response.status_code == 200:
+        content = response.read()
+```
+
+**StreamingResponse attributes:**
+- `status_code` - HTTP status code
+- `headers` - Response headers (case-insensitive)
+- `cookies` - Response cookies
+- `url` - Final URL after redirects
+- `is_closed` - Whether the stream has been closed
+- `is_consumed` - Whether the stream has been fully consumed
+
+**StreamingResponse methods:**
+- `iter_bytes()` - Iterate over response as bytes chunks
+- `iter_text()` - Iterate over response as text chunks (decoded using response encoding)
+- `iter_lines()` - Iterate over response line by line
+- `read()` - Read entire remaining response body into memory
+- `close()` - Close the stream and release resources
+
+**Important notes:**
+- Streaming must be used as a context manager (with statement)
+- Headers, cookies, and status code are available immediately before reading the body
+- The response body is only read when you iterate over it or call `read()`
+- Once consumed, the stream cannot be read again
+- Streaming is supported for all HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+
+#### Examples
+
+```python
+import httpr
+
+# Initialize the client
+client = httpr.Client() 
+
+# GET request
+resp = client.get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# GET request with passing params and setting timeout
+params = {"param1": "value1", "param2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", params=params, timeout=10)
+print(r.text)
+
+# POST Binary Request Data
+content = b"some_data"
+resp = client.post(url="https://httpbin.org/anything", content=content)
+print(r.text)
+
+# POST Form Encoded Data
+data = {"key1": "value1", "key2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", data=data)
+print(r.text)
+
+# POST JSON Encoded Data
+json = {"key1": "value1", "key2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", json=json)
+print(r.text)
+
+# POST Multipart-Encoded Files
+files = {'file1': '/home/root/file1.txt', 'file2': 'home/root/file2.txt'}
+r = client.post("https://httpbin.org/post", files=files)
+print(r.text)
+
+# Authentication using user/password
+auth = ("user", "password")
+resp = client.post(url="https://httpbin.org/anything", auth=auth)
+print(r.text)
+
+# Authentication using auth bearer
+auth_bearer = "bearerXXXXXXXXXXXXXXXXXXXX"
+resp = client.post(url="https://httpbin.org/anything", auth_bearer=auth_bearer)
+print(r.text)
+
+# Using proxy or env var HTTPR_PROXY
+resp = httpr.Client(proxy="http://127.0.0.1:8080").get("https://tls.peet.ws/api/all")
+print(resp.json())
+export HTTPR_PROXY="socks5://127.0.0.1:1080"
+resp = httpr.Client().get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# Using custom CA certificate store: env var HTTPR_CA_BUNDLE
+resp = httpr.Client(ca_cert_file="/cert/cacert.pem").get("https://tls.peet.ws/api/all")
+print(resp.json())
+resp = httpr.Client(ca_cert_file=certifi.where()).get("https://tls.peet.ws/api/all")
+print(resp.json())
+export HTTPR_CA_BUNDLE="/home/user/Downloads/cert.pem"
+resp = httpr.Client().get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# You can also use convenience functions that use a default Client instance under the hood:
+# httpr.get() | httpr.head() | httpr.options() | httpr.delete() | httpr.post() | httpr.patch() | httpr.put()
+resp = httpr.get("https://httpbin.org/anything")
+print(r.text)
+```
+
+### II. AsyncClient
+
+`httpr.AsyncClient()` is an asynchronous wrapper around the `httpr.Client` class, offering the same functions, behavior, and input arguments.
+
+```python
+import asyncio
+import logging
+
+import httpr
+
+async def aget_text(url):
+    async with httpr.AsyncClient() as client:
+        resp = await client.get(url)
+        return resp.text
+
+async def main():
+    urls = ["https://nytimes.com/", "https://cnn.com/", "https://abcnews.go.com/"]
+    tasks = [aget_text(u) for u in urls]
+    results = await asyncio.gather(*tasks)
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    asyncio.run(main())
+```
+
+**Streaming with AsyncClient:**
+
+The `AsyncClient` also supports streaming responses with the same API:
+
+```python
+async with httpr.AsyncClient() as client:
+    async with client.stream("GET", "https://example.com/large-file") as response:
+        for chunk in response.iter_bytes():
+            process(chunk)
+```
+
+Note: While the context manager is async, the iteration over chunks (`iter_bytes()`, `iter_text()`, `iter_lines()`) is synchronous.
+
+## Precompiled wheels
+
+Provides precompiled wheels for the following platforms:
+
+- 🐧 linux: `amd64`, `aarch64`, `armv7` (aarch64 and armv7 builds are `manylinux_2_34` compatible. `ubuntu>=22.04`, `debian>=12`)
+- 🐧 musllinux: `amd64`, `aarch64`
+- 🪟 windows: `amd64`
+- 🍏 macos: `amd64`, `aarch64`.
+
+## Development
+
+This project uses [Taskfile](https://taskfile.dev) for development workflows.
+
+### Setup
+
+```bash
+# Install dependencies
+uv sync --extra dev
+
+# Build Rust extension (required after any .rs changes)
+uv run maturin develop
+
+# Add hosts entry for e2e tests (one-time setup)
+echo '127.0.0.1 httpbun.local' | sudo tee -a /etc/hosts
+```
+
+### Running Tests
+
+```bash
+# List all available tasks
+task --list
+
+# Run unit tests only
+task test:unit
+
+# Run e2e tests (full workflow: start httpbun → test → stop)
+task e2e
+
+# Run e2e tests iteratively (keep httpbun running)
+task e2e:local
+task test:e2e  # run tests against running container
+
+# Run all tests
+task test
+```
+
+### Other Tasks
+
+```bash
+task dev           # Build Rust extension
+task check         # Run all checks (lint + test) - use before committing
+task lint          # Run Python linters (ruff + mypy)
+task lint:rust     # Run Rust linters (fmt + clippy)
+task lint:all      # Run all linters (Python + Rust)
+task fmt           # Format Python code with ruff
+task fmt:rust      # Format Rust code
+task fmt:all       # Format all code (Python + Rust)
+task certs         # Generate SSL certificates for e2e tests
+task httpbun:start # Start httpbun container
+task httpbun:stop  # Stop httpbun container
+task httpbun:logs  # Show container logs
+```
+
+### Test Structure
+
+- `tests/unit/` - Unit tests using pytest-httpbin (fast, no Docker required)
+- `tests/e2e/` - E2E tests using httpbun Docker container with SSL
+
+## CI
+
+| Job | PRs | Push to main | Tags (Release) | Manual |
+|-----|:---:|:------------:|:--------------:|:------:|
+| `lint` | ✓ | | | |
+| `test` (Python 3.10-3.14) | ✓ | ✓ | ✓ | |
+| `docs` (build) | ✓ | | | |
+| `linux`, `musllinux`, `windows`, `macos`, `sdist` | | | ✓ | ✓ |
+| `release` (PyPI publish) | | | ✓ | ✓ |
+| `benchmark` | | | ✓ | ✓ |
+
+- **PRs**: Run lint, tests across Python 3.10-3.14 matrix, and verify docs build
+- **Push to main**: Run tests only
+- **Tags**: Run tests, build wheels, publish stable release to PyPI, run benchmarks
+- **Manual**: Full multi-platform wheel builds with release and benchmarks
+
+## Acknowledgements
+
+- [uv](https://docs.astral.sh/uv/): The package manager used, and for leading the way in the "Rust for python tools"-sphere.
+- [primp](https://github.com/deedy5/primp): *A lot* of code is borrowed from primp, that wraps rust library `rquest` for python in a similar way. If primp supported mTLS, I would have used it instead.
+- [reqwests](https://github.com/seanmonstar/reqwest): The rust library that powers httpr.
+- [pyo3](https://github.com/PyO3/pyo3)
+- [maturin](https://github.com/PyO3/maturin)

httpr-0.3.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+httpr/__init__.py,sha256=rnhHEynCwQXxNquG-oxL9CTzCKWmuc1oqmi9MN85q0Y,30890
+httpr/httpr.cpython-313t-i386-linux-musl.so,sha256=wyyXwIxr_hoMcqgRL8rbt1VnmjXDyr4BQduJruruEOA,4955805
+httpr/httpr.pyi,sha256=JRUdElAkcTXPwGrtRuK1vC-5aS9RQ1BxbYVZA3df7oc,22865
+httpr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpr-0.3.2.dist-info/METADATA,sha256=86C5MwNVmWtmnrWDI-4DpVmq_ES_UQ-97Tl5lTkhebY,18029
+httpr-0.3.2.dist-info/WHEEL,sha256=6ADlOhKFXhEu-Gk8dFo0B1i68er1Rbvld5DrNBBvRuo,107
+httpr-0.3.2.dist-info/licenses/LICENSE,sha256=ZPD9tCar0h91tI4v-TuZdrjDdLqzU4rzPTxtP3x--uc,1063
+httpr.libs/libgcc_s-f5fcfe20.so.1,sha256=AgqyMrWe8E5-efp_cXekgnQn-q6zJOV7u8ZBzQVlfJc,552385
+httpr-0.3.2.dist-info/RECORD,,

{httpr-0.2.5.dist-info → httpr-0.3.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.10.2)
+Generator: maturin (1.11.5)
 Root-Is-Purelib: false
 Tag: cp313-cp313t-musllinux_1_2_i686

httpr-0.2.5.dist-info/METADATA

@@ -1,54 +0,0 @@
-Metadata-Version: 2.4
-Name: httpr
-Version: 0.2.5
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-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: cbor2 ; 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: mkdocs-llmstxt ; extra == 'docs'
-Requires-Dist: matplotlib ; extra == 'benchmark'
-Requires-Dist: pandas ; extra == 'benchmark'
-Requires-Dist: starlette ; extra == 'benchmark'
-Requires-Dist: uvicorn ; extra == 'benchmark'
-Requires-Dist: requests ; extra == 'benchmark'
-Requires-Dist: httpx ; extra == 'benchmark'
-Requires-Dist: tls-client ; extra == 'benchmark'
-Requires-Dist: curl-cffi ; extra == 'benchmark'
-Requires-Dist: pycurl ; extra == 'benchmark'
-Requires-Dist: typing-extensions ; extra == 'benchmark'
-Requires-Dist: aiohttp ; extra == 'benchmark'
-Requires-Dist: cbor2 ; extra == 'benchmark'
-Requires-Dist: jupyter ; extra == 'benchmark'
-Requires-Dist: ipykernel ; extra == 'benchmark'
-Requires-Dist: gunicorn ; extra == 'benchmark'
-Requires-Dist: fastapi ; extra == 'benchmark'
-Provides-Extra: dev
-Provides-Extra: docs
-Provides-Extra: benchmark
-License-File: LICENSE
-Summary: Fast HTTP client for Python
-Keywords: python,request
-Author: thomasht86
-License: MIT License
-Requires-Python: >=3.10

httpr-0.2.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-httpr-0.2.5.dist-info/METADATA,sha256=8ApuM5fZ2FgK1v2uXz0O8iXoKOKrqLIwiG-eSSWPfE8,2379
-httpr-0.2.5.dist-info/WHEEL,sha256=BiRyfV9PO5pr3rBoHoDPBfEga_p-ngzde1sw4WIMGMQ,107
-httpr-0.2.5.dist-info/licenses/LICENSE,sha256=ZPD9tCar0h91tI4v-TuZdrjDdLqzU4rzPTxtP3x--uc,1063
-httpr.libs/libgcc_s-f5fcfe20.so.1,sha256=AgqyMrWe8E5-efp_cXekgnQn-q6zJOV7u8ZBzQVlfJc,552385
-httpr/__init__.py,sha256=KAqXcDD7uC6EcHPIEcsTImTl5AQjPBkYmVuRpe17IPw,30143
-httpr/httpr.cpython-313t-i386-linux-musl.so,sha256=ABpBUaNloXyUSJt1iq-1PpnLu8UhoDHelOR1zd6uvtw,4951709
-httpr/httpr.pyi,sha256=m63ot1LXOmgYMdIQYIrGHUp8WMVm9GW0hpkfwNeohJ8,22605
-httpr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-httpr-0.2.5.dist-info/RECORD,,