httpr 0.3.2__tar.gz → 0.4.0__tar.gz

{httpr-0.3.2 → httpr-0.4.0}/.github/workflows/mkdocs.yml

@@ -36,6 +36,9 @@ jobs:
           # Capture source commit BEFORE switching branches
           SOURCE_COMMIT=$(git rev-parse --short HEAD)
 
+          # Save the built site before switching branches
+          cp -r site /tmp/site-backup
+
           # Fetch gh-pages branch
           git fetch origin gh-pages:gh-pages || true
 
@@ -58,12 +61,12 @@ jobs:
           # Remove all tracked files
           git rm -rf . || true
 
-          # Copy new docs from site/ directory
-          if [ ! -d "site" ] || [ -z "$(ls -A site 2>/dev/null)" ]; then
+          # Copy new docs from backup
+          if [ ! -d "/tmp/site-backup" ] || [ -z "$(ls -A /tmp/site-backup 2>/dev/null)" ]; then
             echo "Error: site/ directory is empty or missing"
             exit 1
           fi
-          cp -r site/* .
+          cp -r /tmp/site-backup/* .
 
           # Restore benchmark data if it existed
           if [ -f /tmp/bench-backup/data.js ] || [ -f /tmp/bench-backup/index.html ]; then

{httpr-0.3.2 → httpr-0.4.0}/Cargo.lock

@@ -481,7 +481,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
 [[package]]
 name = "httpr"
-version = "0.3.2"
+version = "0.4.0"
 dependencies = [
  "anyhow",
  "bytes",

{httpr-0.3.2 → httpr-0.4.0}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "httpr"
 # Version is set dynamically by CI from git tags (e.g., v1.2.3 -> 1.2.3).
 # Do not edit manually. See .github/actions/set-version/ for details.
-version = "0.3.2"
+version = "0.4.0"
 edition = "2021"
 description = "Fast HTTP client for python"
 authors = ["thomasht86"]

{httpr-0.3.2 → httpr-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpr
-Version: 0.3.2
+Version: 0.4.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only

{httpr-0.3.2 → httpr-0.4.0}/benchmark/benchmark_cbor.py

@@ -1,6 +1,6 @@
 """CBOR vs JSON benchmark for httpr.
 
-This benchmark compares JSON and CBOR serialization/deserialization
+This benchmark compares JSON and CBOR response deserialization
 performance for large vector data using httpr only.
 """
 

{httpr-0.3.2 → httpr-0.4.0}/docs/tutorial/making-requests.md

@@ -162,45 +162,6 @@ response = httpr.post(
 print(response.json()["json"])
 ```
 
-### CBOR Data (Transparent)
-
-CBOR (Concise Binary Object Representation) encoding is automatically used when you set the `Accept: application/cbor` header:
-
-```python
-import httpr
-
-# Simply add Accept header - serialization happens transparently
-response = httpr.post(
-    "https://api.example.com/data",
-    json={  # Use json parameter as normal
-        "name": "John Doe",
-        "values": [1, 2, 3, 4, 5],
-        "metadata": {"version": 1}
-    },
-    headers={"Accept": "application/cbor"}  # Triggers CBOR serialization
-)
-
-# Content-Type is automatically set to application/cbor
-# Server receives CBOR-encoded data
-```
-
-CBOR offers several advantages over JSON:
-
-- **Smaller size**: Binary encoding is more compact than text
-- **Faster processing**: No text parsing overhead
-- **Better for binary data**: Native support for byte arrays
-- **Type preservation**: Maintains exact numeric types
-
-Use CBOR when:
-
-- Working with large arrays or datasets
-- Building high-performance APIs
-- Developing IoT or embedded applications
-- Reducing bandwidth usage is critical
-
-!!! note
-    The server must support CBOR requests. Check the API documentation to confirm CBOR is accepted.
-
 ### Form Data
 
 Send URL-encoded form data:

{httpr-0.3.2 → httpr-0.4.0}/docs/tutorial/response-handling.md

@@ -112,11 +112,7 @@ When the server returns `Content-Type: application/cbor`, the `json()` method au
 ```python
 import httpr
 
-# Request CBOR data by setting Accept header
-response = httpr.get(
-    "https://api.example.com/data",
-    headers={"Accept": "application/cbor"}
-)
+response = httpr.get("https://api.example.com/data")
 
 # json() automatically detects and deserializes CBOR based on Content-Type
 data = response.json()  # Works transparently with CBOR!

{httpr-0.3.2 → httpr-0.4.0}/httpr/__init__.py

@@ -42,6 +42,40 @@ else:
 
 from .httpr import CaseInsensitiveHeaderMap, RClient, Response, StreamingResponse
 
+
+class CaseInsensitiveDict(dict[str, str]):
+    """A dict subclass that provides case-insensitive key access."""
+
+    def __getitem__(self, key: str) -> str:
+        return super().__getitem__(key.lower())
+
+    def __setitem__(self, key: str, value: str) -> None:
+        super().__setitem__(key.lower(), value)
+
+    def __delitem__(self, key: str) -> None:
+        super().__delitem__(key.lower())
+
+    def __contains__(self, key: object) -> bool:
+        if not isinstance(key, str):
+            return False
+        return super().__contains__(key.lower())
+
+    def get(self, key: str, default: str | None = None) -> str | None:  # type: ignore[override]
+        return super().get(key.lower(), default)
+
+    def pop(self, key: str, *args: str) -> str:  # type: ignore[override]
+        return super().pop(key.lower(), *args)
+
+    def setdefault(self, key: str, default: str | None = None) -> str | None:  # type: ignore[override]
+        return super().setdefault(key.lower(), default)  # type: ignore[arg-type]
+
+    def update(self, other: dict[str, str] | None = None, **kwargs: str) -> None:  # type: ignore[override]
+        if other is not None:
+            super().update({k.lower(): v for k, v in other.items()})
+        if kwargs:
+            super().update({k.lower(): v for k, v in kwargs.items()})
+
+
 if TYPE_CHECKING:
     from .httpr import ClientRequestParams, HttpMethod, RequestParams
 else:
@@ -207,6 +241,15 @@ class Client(RClient):
         """
         del self
 
+    @property
+    def headers(self) -> dict[str, str]:
+        """Headers configured for this client (case-insensitive access)."""
+        return CaseInsensitiveDict(super().headers)
+
+    @headers.setter
+    def headers(self, value: dict[str, str] | None) -> None:
+        RClient.headers.__set__(self, value)  # type: ignore[attr-defined]
+
     def request(
         self,
         method: HttpMethod,

{httpr-0.3.2 → httpr-0.4.0}/pyproject.toml

@@ -11,7 +11,7 @@ keywords = [ "python", "request",]
 classifiers = [ "Programming Language :: Rust", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Topic :: Internet :: WWW/HTTP", "Topic :: Software Development :: Libraries :: Python Modules",]
 # Version is set dynamically by CI from git tags (e.g., v1.2.3 -> 1.2.3).
 # Do not edit manually. See .github/actions/set-version/ for details.
-version = "0.3.2"
+version = "0.4.0"
 dependencies = []
 [[project.authors]]
 name = "thomasht86"

{httpr-0.3.2 → httpr-0.4.0}/src/lib.rs

@@ -12,7 +12,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use pythonize::depythonize;
 use reqwest::{
-    header::{HeaderValue, ACCEPT, CONTENT_TYPE, COOKIE},
+    header::{HeaderValue, COOKIE},
     multipart,
     redirect::Policy,
     Body, Identity, Method,
@@ -145,7 +145,7 @@ impl RClient {
         let mut client_builder = reqwest::Client::builder();
 
         // Headers || Cookies
-        if headers.is_some() || cookies.is_some() {
+        let headers_headermap = if headers.is_some() || cookies.is_some() {
             let headers = headers.unwrap_or_else(|| IndexMap::with_hasher(RandomState::default()));
             let mut headers_headermap = headers.to_headermap();
             if let Some(cookies) = cookies {
@@ -156,7 +156,10 @@ impl RClient {
                         .map_err(|e| map_anyhow_error(anyhow::Error::new(e)))?,
                 );
             }
-            client_builder = client_builder.default_headers(headers_headermap);
+            client_builder = client_builder.default_headers(headers_headermap.clone());
+            headers_headermap
+        } else {
+            reqwest::header::HeaderMap::new()
         };
 
         // Cookie_store
@@ -231,7 +234,7 @@ impl RClient {
         let client = Arc::new(Mutex::new(
             client_builder.build().map_err(map_reqwest_error)?,
         ));
-        let headers = Arc::new(Mutex::new(reqwest::header::HeaderMap::new()));
+        let headers = Arc::new(Mutex::new(headers_headermap));
 
         Ok(RClient {
             client,
@@ -449,27 +452,9 @@ impl RClient {
                 if let Some(form_data) = data_value {
                     request_builder = request_builder.form(&form_data);
                 }
-                // Json - check if we should use CBOR based on Accept header
+                // Json - always serialize as JSON regardless of Accept header
                 if let Some(json_data) = json_value {
-                    // Check if Accept header is set to application/cbor
-                    let use_cbor = combined_headers
-                        .get(&ACCEPT)
-                        .and_then(|v| v.to_str().ok())
-                        .map(|s| s.contains("application/cbor"))
-                        .unwrap_or(false);
-
-                    if use_cbor {
-                        // Serialize as CBOR
-                        let mut cbor_bytes = Vec::new();
-                        serde_cbor_2::to_writer(&mut cbor_bytes, &json_data)
-                            .map_err(|e| anyhow!("Failed to serialize CBOR: {}", e))?;
-                        request_builder = request_builder
-                            .header(CONTENT_TYPE, "application/cbor")
-                            .body(cbor_bytes);
-                    } else {
-                        // Serialize as JSON (default)
-                        request_builder = request_builder.json(&json_data);
-                    }
+                    request_builder = request_builder.json(&json_data);
                 }
                 // Files
                 if let Some(files) = files {
@@ -640,27 +625,9 @@ impl RClient {
                 if let Some(form_data) = data_value {
                     request_builder = request_builder.form(&form_data);
                 }
-                // Json - check if we should use CBOR based on Accept header
+                // Json - always serialize as JSON regardless of Accept header
                 if let Some(json_data) = json_value {
-                    // Check if Accept header is set to application/cbor
-                    let use_cbor = combined_headers
-                        .get(&ACCEPT)
-                        .and_then(|v| v.to_str().ok())
-                        .map(|s| s.contains("application/cbor"))
-                        .unwrap_or(false);
-
-                    if use_cbor {
-                        // Serialize as CBOR
-                        let mut cbor_bytes = Vec::new();
-                        serde_cbor_2::to_writer(&mut cbor_bytes, &json_data)
-                            .map_err(|e| anyhow!("Failed to serialize CBOR: {}", e))?;
-                        request_builder = request_builder
-                            .header(CONTENT_TYPE, "application/cbor")
-                            .body(cbor_bytes);
-                    } else {
-                        // Serialize as JSON (default)
-                        request_builder = request_builder.json(&json_data);
-                    }
+                    request_builder = request_builder.json(&json_data);
                 }
                 // Files
                 if let Some(files) = files {

httpr-0.4.0/tests/unit/test_cbor.py

@@ -0,0 +1,104 @@
+"""Tests for CBOR response deserialization support."""
+
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import cbor2
+import pytest
+
+import httpr
+
+
+class CborHandler(BaseHTTPRequestHandler):
+    """Serves CBOR responses for testing."""
+
+    def do_GET(self):
+        if self.path == "/cbor/echo":
+            data = {"message": "CBOR response", "count": 42, "items": [1, 2, 3, 4, 5]}
+        elif self.path == "/cbor/large":
+            data = [[i + j * 0.1 for j in range(1024)] for i in range(10)]
+        else:
+            self.send_error(404)
+            return
+        body = cbor2.dumps(data)
+        self.send_response(200)
+        self.send_header("Content-Type", "application/cbor")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format, *args):
+        pass  # Suppress logs during tests
+
+
+@pytest.fixture(scope="module")
+def cbor_server():
+    """Start a simple CBOR test server on a random free port."""
+    server = HTTPServer(("127.0.0.1", 0), CborHandler)
+    port = server.server_address[1]
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    yield f"http://127.0.0.1:{port}"
+    server.shutdown()
+
+
+def test_json_serialization_default(base_url_ssl, ca_bundle):
+    """Test that JSON is used by default when Accept header is not set."""
+    client = httpr.Client(ca_cert_file=ca_bundle)
+
+    test_data = {"test": "data"}
+
+    # Send without Accept header - should use JSON (default)
+    response = client.post(
+        f"{base_url_ssl}/anything",
+        json=test_data,
+    )
+
+    assert response.status_code == 200
+    json_data = response.json()
+
+    # Should use JSON by default
+    assert json_data["headers"]["Content-Type"] == "application/json"
+    assert json_data["json"] == test_data
+
+
+def test_cbor_response_json_auto_detect(cbor_server):
+    """Test that response.json() auto-detects CBOR from Content-Type."""
+    client = httpr.Client()
+    response = client.get(f"{cbor_server}/cbor/echo")
+
+    assert response.status_code == 200
+    assert "application/cbor" in response.headers["content-type"]
+
+    # json() should transparently deserialize CBOR
+    data = response.json()
+    assert data["message"] == "CBOR response"
+    assert data["count"] == 42
+    assert data["items"] == [1, 2, 3, 4, 5]
+
+
+def test_cbor_response_explicit(cbor_server):
+    """Test that response.cbor() explicitly deserializes CBOR."""
+    client = httpr.Client()
+    response = client.get(f"{cbor_server}/cbor/echo")
+
+    assert response.status_code == 200
+
+    # cbor() should explicitly deserialize
+    data = response.cbor()
+    assert data["message"] == "CBOR response"
+    assert data["count"] == 42
+    assert data["items"] == [1, 2, 3, 4, 5]
+
+
+def test_cbor_response_large_data(cbor_server):
+    """Test CBOR deserialization with large dataset."""
+    client = httpr.Client()
+    response = client.get(f"{cbor_server}/cbor/large")
+
+    assert response.status_code == 200
+
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 10
+    assert len(data[0]) == 1024

{httpr-0.3.2 → httpr-0.4.0}/tests/unit/test_client.py

@@ -76,6 +76,7 @@ def test_client_setters(base_url_ssl, ca_bundle):
     assert response.status_code == 200
     assert client.auth == ("user", "password")
     assert client.headers == {"x-test": "TesT"}  # Headers are lowercased (necessary for HTTP/2)
+    assert client.headers["X-Test"] == "TesT"  # but still accessible case-insensitively
     assert client.cookies == {"ccc": "ddd", "cccc": "dddd"}
     assert client.params == {"x": "aaa", "y": "bbb"}
     assert client.timeout == 20.0
@@ -278,6 +279,85 @@ def test_client_post_files(test_files):
     assert json_data["files"] == {"file1": "aaa111", "file2": "bbb222"}
 
 
+def test_constructor_headers_accessible():
+    """Test that headers passed to constructor are accessible via the headers property."""
+    client = httpr.Client(headers={"X-Custom": "value", "User-Agent": "test-agent"})
+    assert client.headers == {"x-custom": "value", "user-agent": "test-agent"}
+    client.close()
+
+
+def test_constructor_headers_with_cookies():
+    """Test that cookies are excluded from headers getter when passed to constructor."""
+    client = httpr.Client(
+        headers={"X-Custom": "value"},
+        cookies={"session": "abc123"},
+    )
+    # Cookies should not appear in headers getter
+    assert client.headers == {"x-custom": "value"}
+    # But cookies should be accessible via cookies getter
+    assert client.cookies == {"session": "abc123"}
+    client.close()
+
+
+def test_constructor_cookies_only():
+    """Test that cookies-only constructor doesn't expose Cookie header."""
+    client = httpr.Client(cookies={"session": "abc123"})
+    # Headers should be empty (no Cookie header exposed)
+    assert client.headers == {}
+    # Cookies should be accessible
+    assert client.cookies == {"session": "abc123"}
+    client.close()
+
+
+def test_setter_overwrites_constructor_headers():
+    """Test that setting headers overwrites constructor headers."""
+    client = httpr.Client(headers={"X-Original": "original"})
+    assert client.headers == {"x-original": "original"}
+    # Overwrite with new headers
+    client.headers = {"X-New": "new"}
+    assert client.headers == {"x-new": "new"}
+    # Original header should be gone
+    assert "x-original" not in client.headers
+    client.close()
+
+
+def test_client_headers_case_insensitive():
+    """Test that client.headers supports case-insensitive access."""
+    client = httpr.Client(headers={"X-Custom": "value", "Content-Type": "application/json"})
+
+    # Case-insensitive access should work
+    assert client.headers["x-custom"] == "value"
+    assert client.headers["X-Custom"] == "value"
+    assert client.headers["X-CUSTOM"] == "value"
+
+    # Contains check should be case-insensitive
+    assert "x-custom" in client.headers
+    assert "X-Custom" in client.headers
+
+    # get() should be case-insensitive
+    assert client.headers.get("X-Custom") == "value"
+    assert client.headers.get("x-custom") == "value"
+
+    # Dict equality should still work (keys are lowercased)
+    assert client.headers == {"x-custom": "value", "content-type": "application/json"}
+
+    # Test mutating methods on the returned dict (doesn't affect client, but should work)
+    headers = client.headers
+    headers["X-New"] = "new-value"
+    assert headers["x-new"] == "new-value"
+
+    del headers["X-New"]
+    assert "x-new" not in headers
+
+    headers["X-Pop"] = "pop-value"
+    assert headers.pop("X-POP") == "pop-value"
+
+    assert headers.setdefault("X-Default", "default") == "default"
+    assert headers["x-default"] == "default"
+
+    client.close()
+
+
 def test_graceful_invalid_header_handling(base_url_ssl, ca_bundle):
     """Test that invalid header values are handled gracefully without crashing."""
     client = httpr.Client(ca_cert_file=ca_bundle)

httpr-0.3.2/tests/unit/test_cbor.py

@@ -1,94 +0,0 @@
-"""Tests for transparent CBOR serialization/deserialization support."""
-
-import cbor2
-import pytest
-
-import httpr
-
-
-def test_cbor_serialization_transparent(base_url_ssl, ca_bundle):
-    """Test transparent CBOR serialization when Accept header is set."""
-    client = httpr.Client(ca_cert_file=ca_bundle)
-
-    # Create test data
-    test_data = {
-        "name": "httpr",
-        "version": "0.1.0",
-        "numbers": [1, 2, 3, 4, 5],
-        "nested": {
-            "key1": "value1",
-            "key2": 42,
-        },
-    }
-
-    # Send with Accept: application/cbor header - should use CBOR automatically
-    response = client.post(f"{base_url_ssl}/anything", json=test_data, headers={"Accept": "application/cbor"})
-
-    assert response.status_code == 200
-    json_data = response.json()
-
-    # httpbin echoes the request, check that Content-Type was set correctly
-    assert json_data["headers"]["Content-Type"] == "application/cbor"
-
-    # Verify the CBOR data was sent by checking the data field exists
-    assert "data" in json_data
-
-
-def test_json_serialization_default(base_url_ssl, ca_bundle):
-    """Test that JSON is used by default when Accept header is not set."""
-    client = httpr.Client(ca_cert_file=ca_bundle)
-
-    test_data = {"test": "data"}
-
-    # Send without Accept header - should use JSON (default)
-    response = client.post(
-        f"{base_url_ssl}/anything",
-        json=test_data,
-    )
-
-    assert response.status_code == 200
-    json_data = response.json()
-
-    # Should use JSON by default
-    assert json_data["headers"]["Content-Type"] == "application/json"
-    assert json_data["json"] == test_data
-
-
-def test_cbor_types():
-    """Test various CBOR data types in serialization."""
-    test_data = {
-        "string": "test",
-        "int": 42,
-        "float": 3.14159,
-        "bool_true": True,
-        "bool_false": False,
-        "null": None,
-        "array": [1, 2, 3],
-        "object": {"nested": "value"},
-    }
-
-    cbor_bytes = cbor2.dumps(test_data)
-    decoded = cbor2.loads(cbor_bytes)
-
-    assert decoded["string"] == "test"
-    assert decoded["int"] == 42
-    assert decoded["float"] == pytest.approx(3.14159)
-    assert decoded["bool_true"] is True
-    assert decoded["bool_false"] is False
-    assert decoded["null"] is None
-    assert decoded["array"] == [1, 2, 3]
-    assert decoded["object"]["nested"] == "value"
-
-
-@pytest.mark.asyncio
-async def test_cbor_async_transparent(base_url_ssl, ca_bundle):
-    """Test transparent CBOR with async client."""
-    async with httpr.AsyncClient(ca_cert_file=ca_bundle) as client:
-        test_data = {"async": True, "value": 999}
-
-        # Use Accept header to trigger CBOR serialization
-        response = await client.post(f"{base_url_ssl}/anything", json=test_data, headers={"Accept": "application/cbor"})
-
-        assert response.status_code == 200
-        json_data = response.json()
-        assert json_data["headers"]["Content-Type"] == "application/cbor"