httpr 0.1.11__tar.gz → 0.1.13__tar.gz

{httpr-0.1.11 → httpr-0.1.13}/PKG-INFO

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

{httpr-0.1.11 → httpr-0.1.13}/httpr/__init__.py

@@ -46,7 +46,7 @@ class Client(RClient):
         ca_cert_file: str | None = None,
         client_pem: str | None = None,
         https_only: bool | None = False,
-        # http2_only: bool | None = False,
+        http2_only: bool | None = False,
     ):
         """
         Args:

{httpr-0.1.11 → httpr-0.1.13}/pyproject.toml

@@ -10,7 +10,7 @@ keywords = [ "python", "request",]
 classifiers = [ "Programming Language :: Rust", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3.8", "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",]
 dynamic = [ "version",]
 dependencies = []
-version = "0.1.11"
+version = "0.1.13"
 [[project.authors]]
 name = "thomasht86"
 

{httpr-0.1.11 → httpr-0.1.13}/src/lib.rs

@@ -26,7 +26,7 @@ use tokio_util::codec::{BytesCodec, FramedRead};
 use tracing;
 
 mod response;
-use response::Response;
+use response::{CaseInsensitiveHeaderMap, Response};
 
 mod traits;
 use traits::{CookiesTraits, HeadersTraits};
@@ -428,7 +428,7 @@ impl RClient {
             content: PyBytes::new(py, &f_buf).unbind(),
             cookies: f_cookies,
             encoding: String::new(),
-            headers: f_headers,
+            headers: CaseInsensitiveHeaderMap::from_indexmap(f_headers),
             status_code: f_status_code,
             url: f_url,
         })

httpr-0.1.13/src/response.rs

@@ -0,0 +1,199 @@
+use crate::utils::{get_encoding_from_content, get_encoding_from_case_insensitive_headers};
+use anyhow::{anyhow, Result};
+use encoding_rs::Encoding;
+use foldhash::fast::RandomState;
+use html2text::{
+    from_read, from_read_with_decorator,
+    render::{RichDecorator, TrivialDecorator},
+};
+use indexmap::IndexMap;
+use pyo3::{prelude::*, types::PyBytes, IntoPyObject};
+use pythonize::pythonize;
+use serde_json::from_slice;
+
+/// A struct representing an HTTP response.
+///
+/// This struct provides methods to access various parts of an HTTP response, such as headers, cookies, status code, and the response body.
+/// It also supports decoding the response body as text or JSON, with the ability to specify the character encoding.
+#[pyclass]
+#[derive(Clone)]
+pub struct CaseInsensitiveHeaderMap {
+    headers: IndexMap<String, String, RandomState>,
+    lowercase_map: IndexMap<String, String, RandomState>,
+}
+
+#[pymethods]
+impl CaseInsensitiveHeaderMap {
+    #[new]
+    fn new() -> Self {
+        CaseInsensitiveHeaderMap {
+            headers: IndexMap::with_hasher(RandomState::default()),
+            lowercase_map: IndexMap::with_hasher(RandomState::default()),
+        }
+    }
+
+    fn __getitem__(&self, key: String) -> PyResult<String> {
+        let lower_key = key.to_lowercase();
+        if let Some(original_key) = self.lowercase_map.get(&lower_key) {
+            if let Some(value) = self.headers.get(original_key) {
+                return Ok(value.clone());
+            }
+        }
+        Err(pyo3::exceptions::PyKeyError::new_err(format!("Header key '{}' not found", key)))
+    }
+
+    fn __contains__(&self, key: String) -> bool {
+        self.lowercase_map.contains_key(&key.to_lowercase())
+    }
+
+    fn __iter__(slf: PyRef<'_, Self>) -> PyResult<Py<PyAny>> {
+        let iter = slf.headers.keys().cloned().collect::<Vec<_>>();
+        Python::with_gil(|py| {
+            let iter_obj = iter.into_pyobject(py)?;
+            let iter_method = iter_obj.getattr("__iter__")?;
+            let py_iter = iter_method.call0()?;
+            Ok(py_iter.into())
+        })
+    }
+
+    fn items(&self) -> Vec<(String, String)> {
+        self.headers.clone().into_iter().collect()
+    }
+
+    fn keys(&self) -> Vec<String> {
+        self.headers.keys().cloned().collect()
+    }
+
+    fn values(&self) -> Vec<String> {
+        self.headers.values().cloned().collect()
+    }
+
+    #[pyo3(signature = (key, default=None))]
+    fn get(&self, key: String, default: Option<String>) -> String {
+        let lower_key = key.to_lowercase();
+        if let Some(original_key) = self.lowercase_map.get(&lower_key) {
+            if let Some(value) = self.headers.get(original_key) {
+                return value.clone();
+            }
+        }
+        default.unwrap_or_default()
+    }
+}
+
+impl CaseInsensitiveHeaderMap {
+    // Helper method to insert a header
+    pub fn insert(&mut self, key: String, value: String) {
+        let lower_key = key.to_lowercase();
+        self.lowercase_map.insert(lower_key, key.clone());
+        self.headers.insert(key, value);
+    }
+
+    // Helper method to build from an IndexMap
+    pub fn from_indexmap(map: IndexMap<String, String, RandomState>) -> Self {
+        let mut headers_map = CaseInsensitiveHeaderMap::new();
+        for (key, value) in map {
+            headers_map.insert(key, value);
+        }
+        headers_map
+    }
+    
+    // Public method to check if a header exists
+    pub fn contains_key(&self, key: &str) -> bool {
+        self.lowercase_map.contains_key(&key.to_lowercase())
+    }
+    
+    // Public method to get a header value
+    pub fn get_value(&self, key: &str) -> Option<String> {
+        let lower_key = key.to_lowercase();
+        if let Some(original_key) = self.lowercase_map.get(&lower_key) {
+            if let Some(value) = self.headers.get(original_key) {
+                return Some(value.clone());
+            }
+        }
+        None
+    }
+}
+
+#[pyclass]
+pub struct Response {
+    #[pyo3(get)]
+    pub content: Py<PyBytes>,
+    #[pyo3(get)]
+    pub cookies: IndexMap<String, String, RandomState>,
+    #[pyo3(get, set)]
+    pub encoding: String,
+    #[pyo3(get)]
+    pub headers: CaseInsensitiveHeaderMap,
+    #[pyo3(get)]
+    pub status_code: u16,
+    #[pyo3(get)]
+    pub url: String,
+}
+
+#[pymethods]
+impl Response {
+    #[getter]
+    fn get_encoding(&mut self, py: Python) -> Result<&String> {
+        if !self.encoding.is_empty() {
+            return Ok(&self.encoding);
+        }
+        self.encoding = get_encoding_from_case_insensitive_headers(&self.headers)
+            .or_else(|| get_encoding_from_content(self.content.as_bytes(py)))
+            .unwrap_or_else(|| "utf-8".to_string());
+        Ok(&self.encoding)
+    }
+
+    #[getter]
+    fn text(&mut self, py: Python) -> Result<String> {
+        // If self.encoding is empty, call get_encoding to populate self.encoding
+        if self.encoding.is_empty() {
+            self.get_encoding(py)?;
+        }
+
+        // Convert Py<PyBytes> to &[u8]
+        let raw_bytes = self.content.as_bytes(py);
+
+        // Release the GIL here because decoding can be CPU-intensive
+        py.allow_threads(|| {
+            let encoding = Encoding::for_label(self.encoding.as_bytes())
+                .ok_or_else(|| anyhow!("Unsupported charset: {}", self.encoding))?;
+            let (decoded_str, detected_encoding, _) = encoding.decode(raw_bytes);
+
+            // Update self.encoding based on the detected encoding
+            if self.encoding != detected_encoding.name() {
+                self.encoding = detected_encoding.name().to_string();
+            }
+
+            Ok(decoded_str.to_string())
+        })
+    }
+
+    fn json(&mut self, py: Python) -> Result<PyObject> {
+        let json_value: serde_json::Value = from_slice(self.content.as_bytes(py))?;
+        let result = pythonize(py, &json_value).unwrap().unbind();
+        Ok(result)
+    }
+
+    #[getter]
+    fn text_markdown(&mut self, py: Python) -> Result<String> {
+        let raw_bytes = self.content.bind(py).as_bytes();
+        let text = py.allow_threads(|| from_read(raw_bytes, 100))?;
+        Ok(text)
+    }
+
+    #[getter]
+    fn text_plain(&mut self, py: Python) -> Result<String> {
+        let raw_bytes = self.content.bind(py).as_bytes();
+        let text =
+            py.allow_threads(|| from_read_with_decorator(raw_bytes, 100, TrivialDecorator::new()))?;
+        Ok(text)
+    }
+
+    #[getter]
+    fn text_rich(&mut self, py: Python) -> Result<String> {
+        let raw_bytes = self.content.bind(py).as_bytes();
+        let text =
+            py.allow_threads(|| from_read_with_decorator(raw_bytes, 100, RichDecorator::new()))?;
+        Ok(text)
+    }
+}

{httpr-0.1.11 → httpr-0.1.13}/src/traits.rs

@@ -40,8 +40,10 @@ impl HeadersTraits for HeaderMap {
         let mut index_map =
             IndexMapSSR::with_capacity_and_hasher(self.len(), RandomState::default());
         for (key, value) in self {
+            // Store the original header name (preserving case)
+            let header_name = key.as_str().to_string();
             index_map.insert(
-                key.as_str().to_string(),
+                header_name,
                 value
                     .to_str()
                     .unwrap_or_else(|v| panic!("Invalid header value: {v:?}"))

{httpr-0.1.11 → httpr-0.1.13}/src/utils.rs

@@ -46,8 +46,13 @@ fn read_pem_certificates(path: &str) -> Result<Vec<Certificate>> {
 }
 
 /// Get encoding from the "Content-Type" header
-
-/// Get encoding from the "Content-Type" header
+/// 
+/// This function is deprecated; use get_encoding_from_case_insensitive_headers instead.
+#[deprecated(
+    since = "0.1.0",
+    note = "use get_encoding_from_case_insensitive_headers instead"
+)]
+#[allow(dead_code)]
 pub fn get_encoding_from_headers(
     headers: &IndexMap<String, String, RandomState>,
 ) -> Option<String> {
@@ -72,6 +77,31 @@ pub fn get_encoding_from_headers(
         })
 }
 
+/// Get encoding from the "Content-Type" header using CaseInsensitiveHeaderMap
+pub fn get_encoding_from_case_insensitive_headers(
+    headers: &crate::response::CaseInsensitiveHeaderMap
+) -> Option<String> {
+    if headers.contains_key("content-type") {
+        let content_type = headers.get_value("content-type")?;
+        
+        // Parse the Content-Type header to separate the media type and parameters
+        let mut parts = content_type.split(';');
+        let media_type = parts.next().unwrap_or("").trim();
+        let params = parts.next().unwrap_or("").trim();
+
+        // Check for specific conditions and return the appropriate encoding
+        if let Some(param) = params.to_ascii_lowercase().strip_prefix("charset=") {
+            Some(param.trim_matches('"').to_ascii_lowercase())
+        } else if media_type == "application/json" {
+            Some("utf-8".to_string())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
 /// Get encoding from the `<meta charset="...">` tag within the first 2048 bytes of HTML content.
 pub fn get_encoding_from_content(raw_bytes: &[u8]) -> Option<String> {
     let start_sequence: &[u8] = b"charset=";

{httpr-0.1.11 → httpr-0.1.13}/tests/test_client.py

@@ -238,6 +238,42 @@ def test_client_post_json():
     assert json_data["args"] == {"x": "aaa", "y": "bbb", "z": "3"}
     assert json_data["json"] == data
 
+@retry()
+def test_client_number_params():
+    client = httpr.Client()
+    params = {
+        "int": 42,
+        "float": 3.14159,
+        "sci_notation": 1.23e-4,
+        "large_float": 1.7976931348623157e+308,
+        "small_float": 0.026305610314011577,
+    }
+    response = client.get("https://httpbin.org/anything", params=params)
+    assert response.status_code == 200
+    json_data = response.json()
+    
+    # Verify all numeric values are converted to strings
+    assert json_data["args"]["int"] == "42"
+    assert json_data["args"]["float"] == "3.14159"
+    assert json_data["args"]["sci_notation"] == "0.000123" or json_data["args"]["sci_notation"] == "1.23e-4"
+    # Large values might have different string representations
+    assert float(json_data["args"]["large_float"]) == 1.7976931348623157e+308
+    assert float(json_data["args"]["small_float"]) == 0.026305610314011577
+
+@retry()
+def test_header_case_preservation():
+    client = httpr.Client()
+    
+    # Send a request to a server that will return case-sensitive headers
+    response = client.get("https://httpbin.org/response-headers?X-Custom-Header=TestValue")
+    
+    # Verify the header case is preserved
+    assert "X-Custom-Header" in response.headers
+    assert response.headers["X-Custom-Header"] == "TestValue"
+    
+    # Also verify headers can be accessed with different cases
+    assert "x-custom-header" in response.headers
+    assert response.headers["x-custom-header"] == "TestValue"
 
 @pytest.fixture(scope="session")
 def test_files(tmp_path_factory):

httpr-0.1.11/src/response.rs

@@ -1,100 +0,0 @@
-use crate::utils::{get_encoding_from_content, get_encoding_from_headers};
-use anyhow::{anyhow, Result};
-use encoding_rs::Encoding;
-use foldhash::fast::RandomState;
-use html2text::{
-    from_read, from_read_with_decorator,
-    render::{RichDecorator, TrivialDecorator},
-};
-use indexmap::IndexMap;
-use pyo3::{prelude::*, types::PyBytes};
-use pythonize::pythonize;
-use serde_json::from_slice;
-
-/// A struct representing an HTTP response.
-///
-/// This struct provides methods to access various parts of an HTTP response, such as headers, cookies, status code, and the response body.
-/// It also supports decoding the response body as text or JSON, with the ability to specify the character encoding.
-#[pyclass]
-pub struct Response {
-    #[pyo3(get)]
-    pub content: Py<PyBytes>,
-    #[pyo3(get)]
-    pub cookies: IndexMap<String, String, RandomState>,
-    #[pyo3(get, set)]
-    pub encoding: String,
-    #[pyo3(get)]
-    pub headers: IndexMap<String, String, RandomState>,
-    #[pyo3(get)]
-    pub status_code: u16,
-    #[pyo3(get)]
-    pub url: String,
-}
-
-#[pymethods]
-impl Response {
-    #[getter]
-    fn get_encoding(&mut self, py: Python) -> Result<&String> {
-        if !self.encoding.is_empty() {
-            return Ok(&self.encoding);
-        }
-        self.encoding = get_encoding_from_headers(&self.headers)
-            .or_else(|| get_encoding_from_content(self.content.as_bytes(py)))
-            .unwrap_or_else(|| "utf-8".to_string());
-        Ok(&self.encoding)
-    }
-
-    #[getter]
-    fn text(&mut self, py: Python) -> Result<String> {
-        // If self.encoding is empty, call get_encoding to populate self.encoding
-        if self.encoding.is_empty() {
-            self.get_encoding(py)?;
-        }
-
-        // Convert Py<PyBytes> to &[u8]
-        let raw_bytes = self.content.as_bytes(py);
-
-        // Release the GIL here because decoding can be CPU-intensive
-        py.allow_threads(|| {
-            let encoding = Encoding::for_label(self.encoding.as_bytes())
-                .ok_or_else(|| anyhow!("Unsupported charset: {}", self.encoding))?;
-            let (decoded_str, detected_encoding, _) = encoding.decode(raw_bytes);
-
-            // Update self.encoding based on the detected encoding
-            if self.encoding != detected_encoding.name() {
-                self.encoding = detected_encoding.name().to_string();
-            }
-
-            Ok(decoded_str.to_string())
-        })
-    }
-
-    fn json(&mut self, py: Python) -> Result<PyObject> {
-        let json_value: serde_json::Value = from_slice(self.content.as_bytes(py))?;
-        let result = pythonize(py, &json_value).unwrap().unbind();
-        Ok(result)
-    }
-
-    #[getter]
-    fn text_markdown(&mut self, py: Python) -> Result<String> {
-        let raw_bytes = self.content.bind(py).as_bytes();
-        let text = py.allow_threads(|| from_read(raw_bytes, 100))?;
-        Ok(text)
-    }
-
-    #[getter]
-    fn text_plain(&mut self, py: Python) -> Result<String> {
-        let raw_bytes = self.content.bind(py).as_bytes();
-        let text =
-            py.allow_threads(|| from_read_with_decorator(raw_bytes, 100, TrivialDecorator::new()))?;
-        Ok(text)
-    }
-
-    #[getter]
-    fn text_rich(&mut self, py: Python) -> Result<String> {
-        let raw_bytes = self.content.bind(py).as_bytes();
-        let text =
-            py.allow_threads(|| from_read_with_decorator(raw_bytes, 100, RichDecorator::new()))?;
-        Ok(text)
-    }
-}

{httpr-0.1.11 → httpr-0.1.13}/.github/workflows/CI.yml

@@ -344,6 +344,10 @@ jobs:
     runs-on: ubuntu-latest
     needs: [linux]
     steps:
+      - name: Checkout main branch
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: |
+          git checkout main
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
@@ -367,10 +371,6 @@ jobs:
         run: python benchmark/benchmark.py
       - name: Generate image
         run: python benchmark/generate_image.py
-      - name: Checkout main branch
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        run: |
-          git checkout main
       - name: Commit generated image if changed
         uses: EndBug/add-and-commit@v9
         with: