httpr 0.3.3__tar.gz → 0.4.1__tar.gz

{httpr-0.3.3 → httpr-0.4.1}/Cargo.lock

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

{httpr-0.3.3 → httpr-0.4.1}/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.3"
+version = "0.4.1"
 edition = "2021"
 description = "Fast HTTP client for python"
 authors = ["thomasht86"]

{httpr-0.3.3 → httpr-0.4.1}/PKG-INFO

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

{httpr-0.3.3 → httpr-0.4.1}/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.3 → httpr-0.4.1}/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.3 → httpr-0.4.1}/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.3 → httpr-0.4.1}/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.3 → httpr-0.4.1}/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.3"
+version = "0.4.1"
 dependencies = []
 [[project.authors]]
 name = "thomasht86"

{httpr-0.3.3 → httpr-0.4.1}/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,
@@ -452,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 {
@@ -643,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.1/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.3 → httpr-0.4.1}/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
@@ -320,6 +321,43 @@ def test_setter_overwrites_constructor_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)