httpr 0.1.0__tar.gz → 0.1.12__tar.gz

{httpr-0.1.0 → httpr-0.1.12}/.github/workflows/CI.yml

@@ -19,6 +19,20 @@ permissions:
   contents: read
 
 jobs:
+  extract-version:
+    runs-on: ubuntu-latest
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+    outputs:
+      version: ${{ steps.get_version.outputs.version }}
+    steps:
+      - name: Extract version from tag
+        id: get_version
+        run: |
+          # Extract version from tag (e.g., v0.1.0 -> 0.1.0)
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          echo "version=$TAG_VERSION" >> $GITHUB_OUTPUT
+          echo "Version extracted: $TAG_VERSION"
+
   linux:
     runs-on: ${{ matrix.platform.runner }}
     strategy:
@@ -47,6 +61,13 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: 3.x
+      # Only modify pyproject.toml temporarily for this job if running from a tag
+      - name: Update version in pyproject.toml
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: |
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          pip install toml
+          python .github/workflows/set_version.py $TAG_VERSION
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -103,13 +124,20 @@ jobs:
             target: x86
           - runner: ubuntu-22.04
             target: aarch64
-          - runner: ubuntu-22.04
-            target: armv7
+          # - runner: ubuntu-22.04
+          #   target: armv7
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
           python-version: 3.x
+      # Only modify pyproject.toml temporarily for this job if running from a tag
+      - name: Update version in pyproject.toml
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: |
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          pip install toml
+          python .github/workflows/set_version.py $TAG_VERSION
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -175,6 +203,14 @@ jobs:
         with:
           python-version: 3.x
           architecture: ${{ matrix.platform.target }}
+      # Only modify pyproject.toml temporarily for this job if running from a tag
+      - name: Update version in pyproject.toml
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        shell: pwsh
+        run: |
+          $TAG_VERSION = $env:GITHUB_REF -replace 'refs/tags/v', ''
+          pip install toml
+          python .github/workflows/set_version.py $TAG_VERSION
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -216,6 +252,13 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: 3.x
+      # Only modify pyproject.toml temporarily for this job if running from a tag
+      - name: Update version in pyproject.toml
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: |
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          pip install toml
+          python .github/workflows/set_version.py $TAG_VERSION
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -246,6 +289,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+      # Only modify pyproject.toml temporarily for this job if running from a tag
+      - name: Update version in pyproject.toml
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: |
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          pip install toml
+          python .github/workflows/set_version.py $TAG_VERSION
       - name: Build sdist
         uses: PyO3/maturin-action@v1
         with:
@@ -292,6 +345,8 @@ jobs:
     needs: [linux]
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
@@ -312,8 +367,14 @@ 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:
           message: "Update generated image"
           add: "*.jpg"
+          default_author: github_actions
+          push: true

{httpr-0.1.0 → httpr-0.1.12}/.github/workflows/mkdocs.yml

@@ -25,5 +25,5 @@ jobs:
           path: .cache
           restore-keys: |
             mkdocs-material-
-      - run: pip install mkdocs-material
+      - run: pip install mkdocs-material[imaging]
       - run: mkdocs gh-deploy --force

httpr-0.1.12/.github/workflows/set_version.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import sys
+
+# Replace tomllib with toml (needs to be installed with pip)
+import toml
+
+
+def update_version(version):
+    """Update project version in pyproject.toml file"""
+    # Get the project root directory (assuming script is in .github/workflows)
+    project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    pyproject_path = os.path.join(project_root, "pyproject.toml")
+
+    # Check if pyproject.toml exists
+    if not os.path.isfile(pyproject_path):
+        print(f"Error: pyproject.toml not found at {pyproject_path}")
+        sys.exit(1)
+
+    try:
+        # Load the pyproject.toml file
+        data = toml.load(pyproject_path)
+
+        # Show the current version
+        current_version = data.get("project", {}).get("version", "unknown")
+        print(f"Current version: {current_version}")
+
+        # Update the version
+        if "project" not in data:
+            print("Error: 'project' section not found in pyproject.toml")
+            sys.exit(1)
+
+        data["project"]["version"] = version
+
+        # Write the updated content back to the file
+        with open(pyproject_path, "w") as f:
+            toml.dump(data, f)
+
+        print(f"Version updated to: {version}")
+
+    except Exception as e:
+        print(f"Error updating version: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Update project version in pyproject.toml")
+    parser.add_argument("version", help="New version to set (e.g., '0.1.0')")
+
+    args = parser.parse_args()
+
+    # Update the version
+    update_version(args.version)

{httpr-0.1.0 → httpr-0.1.12}/.gitignore

@@ -79,4 +79,6 @@ benchmark/*.jpg
 .env
 
 *.pem
-*.key
+*.key
+
+*.dylib

{httpr-0.1.0 → httpr-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpr
-Version: 0.1.0
+Version: 0.1.12
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -22,7 +22,7 @@ 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 ; extra == 'docs'
+Requires-Dist: mkdocs-material[imaging] ; extra == 'docs'
 Requires-Dist: httpr[dev] ; extra == 'scratch'
 Requires-Dist: matplotlib ; extra == 'scratch'
 Requires-Dist: pandas ; extra == 'scratch'
@@ -47,19 +47,24 @@ 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` in most cases.
+**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 0 python-dependencies.
-- **Async**: first-class support for async/await. 
-- **http2**: httpr supports http2.
-- **mTLS**: httpr supports mTLS.
-- **Zero python dependencies**: httpr is a pure rust library with no python dependencies.
+- **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.
+- **http2**: `httpr` supports HTTP/2.
+- **mTLS**: `httpr` supports mTLS.
+
+## Not implemented yet
+
+- **Streaming**: Streaming is not implemented yet.
+- **Fine-grained error handling**: Fine-grained error handling is not implemented yet.
 
 ## Table of Contents
 
 - [httpr](#httpr)
+  - [Not implemented yet](#not-implemented-yet)
   - [Table of Contents](#table-of-contents)
   - [Installation](#installation)
     - [Install with uv](#install-with-uv)
@@ -310,7 +315,8 @@ Provides precompiled wheels for the following platforms:
   
 ## Acknowledgements
 
-- [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.
+- [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.1.0 → httpr-0.1.12}/README.md

@@ -1,18 +1,23 @@
 # httpr
 
-**Blazing fast http-client** for Python in Rust 🦀 that can be used as drop-in replacement for `httpx` in most cases.
+**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 0 python-dependencies.
-- **Async**: first-class support for async/await. 
-- **http2**: httpr supports http2.
-- **mTLS**: httpr supports mTLS.
-- **Zero python dependencies**: httpr is a pure rust library with no python dependencies.
+- **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.
+- **http2**: `httpr` supports HTTP/2.
+- **mTLS**: `httpr` supports mTLS.
+
+## Not implemented yet
+
+- **Streaming**: Streaming is not implemented yet.
+- **Fine-grained error handling**: Fine-grained error handling is not implemented yet.
 
 ## Table of Contents
 
 - [httpr](#httpr)
+  - [Not implemented yet](#not-implemented-yet)
   - [Table of Contents](#table-of-contents)
   - [Installation](#installation)
     - [Install with uv](#install-with-uv)
@@ -263,7 +268,8 @@ Provides precompiled wheels for the following platforms:
   
 ## Acknowledgements
 
-- [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.
+- [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.1.12/docs/writings/index.md

@@ -0,0 +1 @@
+# Blog

httpr-0.1.12/docs/writings/posts/2025-02-24-python-http-clients-suck.md

@@ -0,0 +1,9 @@
+---
+date: 2025-02-25T00:00:00-07:00
+social:
+  cards: true
+---
+
+# Lorem ipsum dolor sit amet
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt est et ultrices eleifend, nunc risus varius orci, in dignissim purus enim quis turpis.

{httpr-0.1.0 → httpr-0.1.12}/httpr/__init__.py

@@ -80,6 +80,10 @@ class Client(RClient):
         # Validate the HTTP method. Raise an exception if it's not supported.
         if method not in ["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]:
             raise ValueError(f"Unsupported HTTP method: {method}")
+            # Convert all params values to strings if params is present
+        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:
@@ -114,11 +118,21 @@ class AsyncClient(Client):
     async def __aexit__(self, *args):
         del self
 
+    async def aclose(self):
+        del self
+        return
+
     async def _run_sync_asyncio(self, fn, *args, **kwargs):
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, partial(fn, *args, **kwargs))
 
     async def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        if method not in ["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+            # Convert all params values to strings if params is present
+        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(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore

httpr-0.1.12/mkdocs.yml

@@ -0,0 +1,41 @@
+site_name: httpr
+site_url: https://thomasht86.github.io/httpr
+plugins:
+  - search
+  - blog:
+      blog_dir: writings
+  - social:
+      enabled: true
+
+nav:
+  - Home: index.md
+  - Docs: docs.md
+  - Blog: writings/index.md
+
+theme:
+  name: material
+  font:
+    text: Lato
+    code: Fira Code
+  features:
+    - content.code.copy
+    - search.suggest
+
+markdown_extensions:
+  - attr_list
+  - admonition
+  - pymdownx.betterem
+  - toc:
+      permalink: true
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+        alternate_style: true
+  - pymdownx.emoji
+  - pymdownx.keys
+  - footnotes

httpr-0.1.12/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = [ "maturin>=1.5,<2.0",]
+build-backend = "maturin"
+
+[project]
+name = "httpr"
+description = "Fast HTTP client for Python"
+requires-python = ">=3.9"
+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.12"
+[[project.authors]]
+name = "thomasht86"
+
+[project.license]
+text = "MIT License"
+
+[project.optional-dependencies]
+dev = [ "certifi", "pytest>=8.1.1", "pytest-asyncio>=0.25.3", "typing_extensions; python_version <= '3.11'", "mypy>=1.14.1", "ruff>=0.9.2", "maturin", "trustme",]
+docs = [ "mkdocs-material[imaging]",]
+scratch = [ "httpr[dev]", "matplotlib", "pandas", "jupyter", "ipykernel", "httpx", "gunicorn", "uvicorn", "trustme", "starlette", "fastapi",]
+
+[tool.maturin]
+features = [ "pyo3/extension-module",]
+
+[tool.ruff]
+line-length = 120
+exclude = [ "tests",]
+
+[tool.mypy]
+python_version = "0.1.5"
+
+[tool.uv]
+[[tool.uv.cache-keys]]
+file = "pyproject.toml"
+
+[[tool.uv.cache-keys]]
+file = "rust/Cargo.toml"
+
+[[tool.uv.cache-keys]]
+file = "**/*.rs"
+
+[tool.ruff.lint]
+select = [ "E", "F", "UP", "B", "SIM", "I",]
+
+[tool.uv.workspace]
+members = [ "benchmark",]

{httpr-0.1.0 → httpr-0.1.12}/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,
         })
@@ -440,5 +440,6 @@ fn httpr(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     pyo3_log::init();
 
     m.add_class::<RClient>()?;
+    m.add_class::<Response>()?;
     Ok(())
 }

httpr-0.1.12/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.0 → httpr-0.1.12}/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:?}"))