httpr 0.7.2__tar.gz → 0.7.4__tar.gz

{httpr-0.7.2 → httpr-0.7.4}/.github/workflows/CI.yml

@@ -190,13 +190,25 @@ jobs:
       matrix:
         platform:
           - runner: ubuntu-22.04
-            target: x86_64
+            target: x86_64-unknown-linux-gnu
+            arch: x86_64
+            manylinux: auto
           - runner: ubuntu-22.04
-            target: x86
+            target: i686-unknown-linux-gnu
+            arch: x86
+            manylinux: auto
           - runner: ubuntu-24.04-arm
-            target: aarch64
+            target: aarch64-unknown-linux-gnu
+            arch: aarch64
+            manylinux: auto
           - runner: ubuntu-22.04
-            target: armv7
+            target: armv7-unknown-linux-gnueabihf
+            arch: armv7
+            manylinux: auto
+          - runner: ubuntu-24.04-riscv
+            target: riscv64gc-unknown-linux-gnu
+            arch: riscv64
+            manylinux: 2_39
           # - runner: ubuntu-22.04
           #   target: s390x
           # - runner: ubuntu-22.04
@@ -216,21 +228,21 @@ jobs:
           target: ${{ matrix.platform.target }}
           args: --release --out dist
           sccache: true
-          manylinux: auto
+          manylinux: ${{ matrix.platform.manylinux }}
       - name: Build free-threaded wheels
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist -i python3.14t
           sccache: true
-          manylinux: auto
+          manylinux: ${{ matrix.platform.manylinux }}
       - name: Upload wheels
         uses: actions/upload-artifact@v6
         with:
-          name: wheels-linux-${{ matrix.platform.target }}
+          name: wheels-linux-${{ matrix.platform.arch }}
           path: dist
       - name: pytest
-        if: ${{ matrix.platform.target == 'x86_64' || matrix.platform.target == 'aarch64' }}
+        if: ${{ matrix.platform.arch == 'x86_64' || matrix.platform.arch == 'aarch64' }}
         shell: bash
         env:
           RUSTC_WRAPPER: ""
@@ -249,11 +261,14 @@ jobs:
       matrix:
         platform:
           - runner: ubuntu-22.04
-            target: x86_64
+            target: x86_64-unknown-linux-musl
+            arch: x86_64
           - runner: ubuntu-22.04
-            target: x86
+            target: i686-unknown-linux-musl
+            arch: x86
           - runner: ubuntu-24.04-arm
-            target: aarch64
+            target: aarch64-unknown-linux-musl
+            arch: aarch64
           # - runner: ubuntu-22.04
           #   target: armv7
     steps:
@@ -282,10 +297,10 @@ jobs:
       - name: Upload wheels
         uses: actions/upload-artifact@v6
         with:
-          name: wheels-musllinux-${{ matrix.platform.target }}
+          name: wheels-musllinux-${{ matrix.platform.arch }}
           path: dist
       - name: pytest
-        if: ${{ matrix.platform.target == 'x86_64' || matrix.platform.target == 'aarch64' }}
+        if: ${{ matrix.platform.arch == 'x86_64' || matrix.platform.arch == 'aarch64' }}
         uses: addnab/docker-run-action@v3
         with:
           image: alpine:latest

{httpr-0.7.2 → httpr-0.7.4}/CLAUDE.md

@@ -186,7 +186,13 @@ builds in debug mode and the numbers are meaningless.
 
 ### Proxy
 - Set via `proxy` param or `HTTPR_PROXY` env var; the env var is read once in `new()`, never in the setter
-- Changing `client.proxy` rebuilds the entire reqwest client (expensive). `RClient.config: ClientConfig` keeps the construction settings (loaded root certs, mTLS `Identity`, redirects, verify, https_only, http2_only, cookie_store, referer) and `ClientConfig::build()` is the single place a `reqwest::Client` is built, used by `new()` and `set_proxy()`; add any new builder setting there, not inline (issue #84). The setter takes `Option<String>`; `None` removes the proxy. The rebuilt client starts with an empty cookie store
+- Changing `client.proxy` rebuilds the entire reqwest client (expensive). `RClient.config: ClientConfig` keeps the construction settings (loaded root certs, mTLS `Identity`, redirects, verify, https_only, http2_only, http1_only, cookie_store, referer) and `ClientConfig::build()` is the single place a `reqwest::Client` is built, used by `new()` and `set_proxy()`; add any new builder setting there, not inline (issue #84). The setter takes `Option<String>`; `None` removes the proxy. The rebuilt client starts with an empty cookie store
+
+### HTTP Version (issue #113)
+- Default (`http2_only=False`, `http1_only=False`) is reqwest's ALPN negotiation: HTTP/2 over TLS when the server offers it, else HTTP/1.1; plain `http://` is HTTP/1.1. It is not "HTTP/1 only", whatever older docs said
+- `http2_only=True` → `http2_prior_knowledge()` (h2c on `http://`); `http1_only=True` → `http1_only()`; both at once raises `ValueError` in `new()`. Both live in `ClientConfig`
+- pyvespa relies on both current modes (sync client: negotiation, gets h2 on Vespa Cloud; `VespaAsync`: `http2_only=True`, h2c locally). Do not switch the default to httpx's HTTP/1.1-only or deprecate `http2_only` without Thomas's approval (issue #111)
+- `Response.http_version` / `StreamingResponse.http_version` use httpx spelling (`"HTTP/1.1"`, `"HTTP/2"`), set from `ResponseMeta::from_response` in `src/response.rs`
 
 ### Client Lifecycle (issue #88)
 - All lifecycle state lives in `src/lifecycle.rs`: `ClientState` (`Arc`-shared between an `RClient` and its in-flight requests) holds `client: Mutex<Option<reqwest::Client>>`, an `in_flight` counter and a `CancellationToken` for pending connects. `RClient::close()` takes the client (`None`); dropping the `reqwest::Client` drops the client's handle to its connection pool

{httpr-0.7.2 → httpr-0.7.4}/Cargo.lock

@@ -516,7 +516,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
 [[package]]
 name = "httpr"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "anyhow",
  "bytes",

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

{httpr-0.7.2 → httpr-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpr
-Version: 0.7.2
+Version: 0.7.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -149,7 +149,11 @@ class Client:
         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`.
+        http2_only` (bool | None): Speak HTTP/2 from the first byte (prior knowledge), including cleartext h2c on
+            `http://` URLs. Default is `false`, which negotiates: over TLS, HTTP/2 when the server offers it,
+            otherwise HTTP/1.1; plain `http://` uses HTTP/1.1.
+        http1_only` (bool | None): Only use HTTP/1.1, never HTTP/2. Cannot be combined with `http2_only`.
+            Default is `false`.
 
     """
 ```

{httpr-0.7.2 → httpr-0.7.4}/README.md

@@ -105,7 +105,11 @@ class Client:
         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`.
+        http2_only` (bool | None): Speak HTTP/2 from the first byte (prior knowledge), including cleartext h2c on
+            `http://` URLs. Default is `false`, which negotiates: over TLS, HTTP/2 when the server offers it,
+            otherwise HTTP/1.1; plain `http://` uses HTTP/1.1.
+        http1_only` (bool | None): Only use HTTP/1.1, never HTTP/2. Cannot be combined with `http2_only`.
+            Default is `false`.
 
     """
 ```

{httpr-0.7.2 → httpr-0.7.4}/docs/advanced/proxy.md

@@ -101,7 +101,7 @@ client.proxy = None
 
 Every other setting from construction is carried over: `verify`, `ca_cert_file`,
 the mTLS identity, `follow_redirects`/`max_redirects`, `https_only`, `http2_only`,
-the current headers and the timeout. Two things to know:
+`http1_only`, the current headers and the timeout. Two things to know:
 
 - Assigning `None` removes the proxy; the `HTTPR_PROXY` environment variable is
   only consulted when the client is constructed.

{httpr-0.7.2 → httpr-0.7.4}/docs/advanced/ssl-tls.md

@@ -173,21 +173,30 @@ with client:
     print(response.json())
 ```
 
-## HTTP/2
+## HTTP version
 
-httpr supports HTTP/2 over TLS:
+By default httpr negotiates the protocol: over TLS it offers both HTTP/2 and
+HTTP/1.1 (ALPN) and uses HTTP/2 whenever the server supports it; plain `http://`
+URLs use HTTP/1.1. `response.http_version` tells you which one was used.
 
 ```python
 import httpr
 
-# HTTP/2 only mode
-client = httpr.Client(http2_only=True)
+client = httpr.Client()
 response = client.get("https://http2.example.com")
+print(response.http_version)  # "HTTP/2" if the server supports it, else "HTTP/1.1"
+
+# Never use HTTP/2
+client = httpr.Client(http1_only=True)
+
+# Speak HTTP/2 from the first byte, also over plain http:// (h2c)
+client = httpr.Client(http2_only=True)
 ```
 
 !!! note
-    HTTP/2 requires TLS. The `http2_only` option forces HTTP/2 protocol.
-    When `http2_only=False` (default), httpr uses HTTP/1.1.
+    `http2_only=True` skips negotiation (HTTP/2 "prior knowledge"), so the server
+    must support HTTP/2; over `http://` it must accept cleartext h2c. `http1_only`
+    and `http2_only` cannot both be set.
 
 ## HTTPS Only Mode
 
@@ -280,7 +289,7 @@ The CA certificate chain is incomplete:
 Protocol mismatch:
 
 1. Server may not support modern TLS versions
-2. Try `http2_only=False` if using HTTP/2
+2. Try `http1_only=True` to rule out HTTP/2, or drop `http2_only=True` if the server does not support HTTP/2
 
 ### mTLS Errors
 

{httpr-0.7.2 → httpr-0.7.4}/docs/api/index.md

@@ -48,6 +48,7 @@ client = httpr.Client(
     # Protocol
     https_only=False,
     http2_only=False,
+    http1_only=False,
 )
 ```
 

{httpr-0.7.2 → httpr-0.7.4}/docs/api/response.md

@@ -208,6 +208,24 @@ print(response.url)  # https://httpbin.org/get
 
 ---
 
+### http_version
+
+```python
+@property
+def http_version(self) -> str
+```
+
+The protocol the response arrived over: `"HTTP/1.1"` or `"HTTP/2"` (also
+`"HTTP/1.0"`, `"HTTP/0.9"` or `"HTTP/3"`). Also available on streaming responses.
+
+**Example:**
+```python
+response = httpr.get("https://httpbin.org/get")
+print(response.http_version)  # HTTP/2
+```
+
+---
+
 ### encoding
 
 ```python

{httpr-0.7.2 → httpr-0.7.4}/docs/tutorial/making-requests.md

@@ -326,20 +326,30 @@ response = client.get("https://example.com")
 # response = client.get("http://example.com")
 ```
 
-### HTTP/2
+### HTTP version
 
-Enable HTTP/2 only mode:
+By default httpr negotiates the protocol: over TLS it offers both HTTP/2 and
+HTTP/1.1 (ALPN) and uses HTTP/2 whenever the server supports it; plain `http://`
+URLs use HTTP/1.1. `response.http_version` tells you which one was used.
 
 ```python
 import httpr
 
-# Use only HTTP/2
+client = httpr.Client()
+response = client.get("https://http2.example.com")
+print(response.http_version)  # "HTTP/2" if the server supports it, else "HTTP/1.1"
+
+# Never use HTTP/2
+client = httpr.Client(http1_only=True)
+
+# Speak HTTP/2 from the first byte, also over plain http:// (h2c)
 client = httpr.Client(http2_only=True)
-response = client.get("https://example.com")
 ```
 
 !!! note
-    When `http2_only=False` (default), httpr uses HTTP/1.1. Set to `True` for HTTP/2.
+    `http2_only=True` skips negotiation (HTTP/2 "prior knowledge"), so the server
+    must support HTTP/2; over `http://` it must accept cleartext h2c. `http1_only`
+    and `http2_only` cannot both be set.
 
 ## Complete Example
 

{httpr-0.7.2 → httpr-0.7.4}/httpr/__init__.py

@@ -223,6 +223,7 @@ class Client(RClient):
         client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
+        http1_only: bool | None = False,
     ):
         """
         Initialize an HTTP client.
@@ -253,7 +254,12 @@ class Client(RClient):
             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.
+            http2_only: Speak HTTP/2 from the first byte (prior knowledge), including
+                cleartext h2c on `http://` URLs. Default is False, which negotiates:
+                over TLS, HTTP/2 when the server offers it (ALPN), otherwise HTTP/1.1;
+                plain `http://` uses HTTP/1.1.
+            http1_only: Only use HTTP/1.1, never HTTP/2. Default is False. Cannot be
+                combined with `http2_only`.
 
         Example:
             ```python
@@ -686,6 +692,11 @@ class AsyncStreamingResponse:
         """Final URL after any redirects."""
         return self._response.url
 
+    @property
+    def http_version(self) -> str:
+        """Protocol the response arrived over, e.g. "HTTP/1.1" or "HTTP/2"."""
+        return self._response.http_version
+
     @property
     def is_informational(self) -> bool:
         """True for 1xx status codes."""

{httpr-0.7.2 → httpr-0.7.4}/httpr/httpr.pyi

@@ -181,6 +181,10 @@ class Response:
         """Final URL after any redirects."""
         ...
     @property
+    def http_version(self) -> str:
+        """Protocol the response arrived over, e.g. "HTTP/1.1" or "HTTP/2"."""
+        ...
+    @property
     def encoding(self) -> str:
         """
         Character encoding of the response.
@@ -314,6 +318,10 @@ class StreamingResponse:
         """Final URL after any redirects."""
         ...
     @property
+    def http_version(self) -> str:
+        """Protocol the response arrived over, e.g. "HTTP/1.1" or "HTTP/2"."""
+        ...
+    @property
     def is_closed(self) -> bool:
         """Whether the stream has been closed."""
         ...
@@ -381,6 +389,7 @@ class RClient:
         client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
+        http1_only: bool | None = False,
     ): ...
     @property
     def headers(self) -> dict[str, str]: ...
@@ -479,6 +488,7 @@ class Client(RClient):
         client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
+        http1_only: bool | None = False,
     ) -> None:
         """
         Initialize an HTTP client.
@@ -503,7 +513,12 @@ class Client(RClient):
             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.
+            http2_only: Speak HTTP/2 from the first byte (prior knowledge), including
+                cleartext h2c on `http://` URLs. Default is False, which negotiates:
+                over TLS, HTTP/2 when the server offers it (ALPN), otherwise HTTP/1.1;
+                plain `http://` uses HTTP/1.1.
+            http1_only: Only use HTTP/1.1, never HTTP/2. Default is False. Cannot be
+                combined with `http2_only`.
         """
         ...
     def __enter__(self) -> Client: ...
@@ -588,6 +603,7 @@ class AsyncClient(Client):
         client_pem_data: bytes | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
+        http1_only: bool | None = False,
         max_concurrency: int | None = 64,
     ) -> None:
         """Initialize an async HTTP client.

{httpr-0.7.2 → httpr-0.7.4}/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.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "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.7.2"
+version = "0.7.4"
 dependencies = []
 [[project.authors]]
 name = "thomasht86"

{httpr-0.7.2 → httpr-0.7.4}/src/lib.rs

@@ -27,7 +27,9 @@ use tokio_util::codec::{BytesCodec, FramedRead};
 use tokio_util::sync::CancellationToken;
 
 mod response;
-use response::{CaseInsensitiveHeaderMap, LineIterator, Response, StreamingResponse, TextIterator};
+use response::{
+    CaseInsensitiveHeaderMap, LineIterator, Response, ResponseMeta, StreamingResponse, TextIterator,
+};
 
 mod params;
 use params::{merge_params, normalize_params, params_to_py, Pairs};
@@ -76,6 +78,7 @@ struct ClientConfig {
     identity: Option<Identity>,
     https_only: bool,
     http2_only: bool,
+    http1_only: bool,
 }
 
 impl ClientConfig {
@@ -118,9 +121,14 @@ impl ClientConfig {
         if let Some(identity) = &self.identity {
             builder = builder.identity(identity.clone());
         }
+        // Neither flag: ALPN offers h2 and http/1.1 over TLS, plain http:// is
+        // HTTP/1.1. `new()` rejects both flags at once.
         if self.http2_only {
             builder = builder.http2_prior_knowledge();
         }
+        if self.http1_only {
+            builder = builder.http1_only();
+        }
         builder.build().map_err(map_reqwest_error)
     }
 }
@@ -325,21 +333,6 @@ async fn send_request(
     timeout::with_timeout(timeout, Phase::Headers, builder.send()).await
 }
 
-/// Cookies, headers, status and final URL of a response.
-fn response_meta(resp: &reqwest::Response) -> (IndexMapSSR, IndexMapSSR, u16, String) {
-    let cookies: IndexMapSSR = resp
-        .cookies()
-        .map(|cookie| (cookie.name().to_string(), cookie.value().to_string()))
-        .collect();
-    let headers: IndexMapSSR = resp.headers().to_indexmap();
-    (
-        cookies,
-        headers,
-        resp.status().as_u16(),
-        resp.url().to_string(),
-    )
-}
-
 #[pymethods]
 impl RClient {
     /// Initializes an HTTP client that can impersonate web browsers.
@@ -366,7 +359,11 @@ impl RClient {
     /// * `verify` - An optional boolean indicating whether to verify SSL certificates. Default is `true`.
     /// * `ca_cert_file` - Path to CA certificate store. Default is None.
     /// * `https_only` - Restrict the Client to be used with HTTPS only requests. Default is `false`.
-    /// * `http2_only` - If true - use only HTTP/2, if false - use only HTTP/1. Default is `false`.
+    /// * `http2_only` - Speak HTTP/2 from the first byte (prior knowledge), including cleartext h2c on
+    ///         `http://` URLs. Default is `false`, which negotiates: over TLS, HTTP/2 when the server
+    ///         offers it via ALPN, otherwise HTTP/1.1; plain `http://` uses HTTP/1.1.
+    /// * `http1_only` - Only use HTTP/1.1, never HTTP/2. Default is `false`. Cannot be combined with
+    ///         `http2_only`.
     ///
     /// # Example
     ///
@@ -394,7 +391,7 @@ impl RClient {
     #[new]
     #[pyo3(signature = (auth=None, auth_bearer=None, params=None, headers=None, cookies=None,
         cookie_store=true, referer=true, proxy=None, timeout=30.0, follow_redirects=true,
-        max_redirects=20, verify=true, ca_cert_file=None, client_pem=None, client_pem_data=None, https_only=false, http2_only=false))]
+        max_redirects=20, verify=true, ca_cert_file=None, client_pem=None, client_pem_data=None, https_only=false, http2_only=false, http1_only=false))]
     fn new(
         auth: Option<(String, Option<String>)>,
         auth_bearer: Option<String>,
@@ -413,12 +410,20 @@ impl RClient {
         client_pem_data: Option<Vec<u8>>,
         https_only: Option<bool>,
         http2_only: Option<bool>,
+        http1_only: Option<bool>,
     ) -> PyResult<Self> {
         if client_pem.is_some() && client_pem_data.is_some() {
             return Err(PyValueError::new_err(
                 "Only one of client_pem or client_pem_data may be set.",
             ));
         }
+        let http2_only = http2_only.unwrap_or(false);
+        let http1_only = http1_only.unwrap_or(false);
+        if http1_only && http2_only {
+            return Err(PyValueError::new_err(
+                "Only one of http1_only or http2_only may be set.",
+            ));
+        }
         let params = params.map(|p| normalize_params(p, "params")).transpose()?;
 
         // Headers || Cookies
@@ -476,7 +481,8 @@ impl RClient {
             root_certs,
             identity,
             https_only: https_only.unwrap_or(false),
-            http2_only: http2_only.unwrap_or(false),
+            http2_only,
+            http1_only,
         };
 
         let connects = CancellationToken::new();
@@ -727,17 +733,11 @@ impl RClient {
 
         let future = async move {
             let resp = send_request(builder, files, timeout).await?;
-            let (cookies, headers, status_code, url) = response_meta(&resp);
+            let meta = ResponseMeta::from_response(&resp);
             let buf = timeout::read_body(resp, timeout).await?;
 
-            tracing::info!("response: {} {} {}", url, status_code, buf.len());
-            Ok::<(Bytes, IndexMapSSR, IndexMapSSR, u16, String), anyhow::Error>((
-                buf,
-                cookies,
-                headers,
-                status_code,
-                url,
-            ))
+            tracing::info!("response: {} {} {}", meta.url, meta.status_code, buf.len());
+            Ok::<(Bytes, ResponseMeta), anyhow::Error>((buf, meta))
         };
 
         // Execute an async future, releasing the Python GIL for concurrency.
@@ -752,17 +752,9 @@ impl RClient {
             drop(in_flight);
             result
         });
-        let (f_buf, f_cookies, f_headers, f_status_code, f_url) =
-            result.map_err(map_anyhow_error)?;
-
-        Ok(Response {
-            content: PyBytes::new(py, &f_buf).unbind(),
-            cookies: f_cookies,
-            encoding: String::new(),
-            headers: CaseInsensitiveHeaderMap::from_indexmap(f_headers),
-            status_code: f_status_code,
-            url: f_url,
-        })
+        let (buf, meta) = result.map_err(map_anyhow_error)?;
+
+        Ok(Response::new(PyBytes::new(py, &buf).unbind(), meta))
     }
 
     /// Constructs an HTTP request and returns a StreamingResponse for iterating over chunks.
@@ -823,34 +815,19 @@ impl RClient {
         let future = async move {
             // Send the request and await the response (but don't read body)
             let resp = send_request(builder, files, timeout).await?;
-            let (cookies, headers, status_code, url) = response_meta(&resp);
-
-            tracing::info!("streaming response: {} {}", url, status_code);
-            Ok::<(reqwest::Response, IndexMapSSR, IndexMapSSR, u16, String), anyhow::Error>((
-                resp,
-                cookies,
-                headers,
-                status_code,
-                url,
-            ))
+            let meta = ResponseMeta::from_response(&resp);
+
+            tracing::info!("streaming response: {} {}", meta.url, meta.status_code);
+            Ok::<(reqwest::Response, ResponseMeta), anyhow::Error>((resp, meta))
         };
 
         // Execute an async future, releasing the Python GIL for concurrency.
         let result = py.detach(|| RUNTIME.block_on(future));
-        let (f_resp, f_cookies, f_headers, f_status_code, f_url) =
-            result.map_err(map_anyhow_error)?;
+        let (resp, meta) = result.map_err(map_anyhow_error)?;
 
         // The response keeps the request in flight until it is closed: its
         // connection stays busy, and a `close()` meanwhile must wait for it.
-        Ok(StreamingResponse::new(
-            f_resp,
-            in_flight,
-            f_cookies,
-            CaseInsensitiveHeaderMap::from_indexmap(f_headers),
-            f_status_code,
-            f_url,
-            timeout,
-        ))
+        Ok(StreamingResponse::new(resp, in_flight, meta, timeout))
     }
 }
 

{httpr-0.7.2 → httpr-0.7.4}/src/response.rs

@@ -5,6 +5,7 @@
 use crate::exceptions::{map_anyhow_error, HTTPStatusError, StreamClosed, StreamConsumed};
 use crate::lifecycle::InFlight;
 use crate::timeout::{next_chunk, read_body, TimedOut};
+use crate::traits::HeadersTraits;
 use crate::utils::{get_encoding_from_case_insensitive_headers, get_encoding_from_content};
 use crate::RUNTIME;
 use anyhow::{anyhow, Result};
@@ -192,6 +193,43 @@ impl CaseInsensitiveHeaderMap {
     }
 }
 
+/// The protocol version as httpx spells it (`response.http_version`).
+fn http_version_str(version: reqwest::Version) -> &'static str {
+    match version {
+        reqwest::Version::HTTP_09 => "HTTP/0.9",
+        reqwest::Version::HTTP_10 => "HTTP/1.0",
+        reqwest::Version::HTTP_11 => "HTTP/1.1",
+        reqwest::Version::HTTP_2 => "HTTP/2",
+        reqwest::Version::HTTP_3 => "HTTP/3",
+        _ => "HTTP/unknown",
+    }
+}
+
+/// Everything about a response except its body: what both `Response` and
+/// `StreamingResponse` are built from.
+pub struct ResponseMeta {
+    pub cookies: IndexMap<String, String, RandomState>,
+    pub headers: CaseInsensitiveHeaderMap,
+    pub status_code: u16,
+    pub url: String,
+    pub http_version: &'static str,
+}
+
+impl ResponseMeta {
+    pub fn from_response(resp: &reqwest::Response) -> Self {
+        ResponseMeta {
+            cookies: resp
+                .cookies()
+                .map(|cookie| (cookie.name().to_string(), cookie.value().to_string()))
+                .collect(),
+            headers: CaseInsensitiveHeaderMap::from_indexmap(resp.headers().to_indexmap()),
+            status_code: resp.status().as_u16(),
+            url: resp.url().to_string(),
+            http_version: http_version_str(resp.version()),
+        }
+    }
+}
+
 #[pyclass]
 pub struct Response {
     #[pyo3(get)]
@@ -206,10 +244,31 @@ pub struct Response {
     pub status_code: u16,
     #[pyo3(get)]
     pub url: String,
+    pub http_version: &'static str,
+}
+
+impl Response {
+    pub fn new(content: Py<PyBytes>, meta: ResponseMeta) -> Self {
+        Response {
+            content,
+            cookies: meta.cookies,
+            encoding: String::new(),
+            headers: meta.headers,
+            status_code: meta.status_code,
+            url: meta.url,
+            http_version: meta.http_version,
+        }
+    }
 }
 
 #[pymethods]
 impl Response {
+    /// The protocol the response arrived over: `"HTTP/1.1"`, `"HTTP/2"`, ...
+    #[getter]
+    fn http_version(&self) -> &'static str {
+        self.http_version
+    }
+
     #[getter]
     fn reason_phrase(&self) -> &'static str {
         reason_phrase(self.status_code)
@@ -369,6 +428,7 @@ pub struct StreamingResponse {
     pub status_code: u16,
     #[pyo3(get)]
     pub url: String,
+    http_version: &'static str,
     closed: Arc<Mutex<bool>>,
     consumed: Arc<Mutex<bool>>,
     encoding: Arc<Mutex<Option<String>>>,
@@ -385,18 +445,16 @@ impl StreamingResponse {
     pub fn new(
         response: reqwest::Response,
         in_flight: InFlight,
-        cookies: IndexMap<String, String, RandomState>,
-        headers: CaseInsensitiveHeaderMap,
-        status_code: u16,
-        url: String,
+        meta: ResponseMeta,
         timeout: Option<Duration>,
     ) -> Self {
         StreamingResponse {
             response: Arc::new(Mutex::new(Some(response))),
-            cookies,
-            headers,
-            status_code,
-            url,
+            cookies: meta.cookies,
+            headers: meta.headers,
+            status_code: meta.status_code,
+            url: meta.url,
+            http_version: meta.http_version,
             closed: Arc::new(Mutex::new(false)),
             consumed: Arc::new(Mutex::new(false)),
             encoding: Arc::new(Mutex::new(None)),
@@ -447,6 +505,12 @@ impl StreamingResponse {
 
 #[pymethods]
 impl StreamingResponse {
+    /// The protocol the response arrived over: `"HTTP/1.1"`, `"HTTP/2"`, ...
+    #[getter]
+    fn http_version(&self) -> &'static str {
+        self.http_version
+    }
+
     #[getter]
     fn reason_phrase(&self) -> &'static str {
         reason_phrase(self.status_code)

httpr-0.7.4/tests/e2e/test_http_version.py

@@ -0,0 +1,48 @@
+"""E2E protocol selection tests against httpbun over TLS, which offers h2 (issue #113)."""
+
+import pytest
+
+import httpr
+
+
+@pytest.mark.e2e
+class TestHttpVersion:
+    def test_default_negotiates_http2(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        """`http2_only=False` (the default) is ALPN negotiation, not HTTP/1-only."""
+        with httpr.Client(ca_cert_file=e2e_ca_cert) as client:
+            assert client.get(f"{e2e_base_url}/get").http_version == "HTTP/2"
+
+    def test_http2_only(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        with httpr.Client(ca_cert_file=e2e_ca_cert, http2_only=True) as client:
+            assert client.get(f"{e2e_base_url}/get").http_version == "HTTP/2"
+
+    def test_http1_only(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        with httpr.Client(ca_cert_file=e2e_ca_cert, http1_only=True) as client:
+            response = client.get(f"{e2e_base_url}/get")
+            assert response.status_code == 200
+            assert response.http_version == "HTTP/1.1"
+
+    def test_http1_only_streaming(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        with httpr.Client(ca_cert_file=e2e_ca_cert, http1_only=True) as client:
+            with client.stream("GET", f"{e2e_base_url}/get") as response:
+                assert response.http_version == "HTTP/1.1"
+
+    def test_http1_only_survives_proxy_rebuild(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        """Assigning `proxy` rebuilds the reqwest client from `ClientConfig` (issue #84)."""
+        client = httpr.Client(ca_cert_file=e2e_ca_cert, http1_only=True)
+        client.proxy = None
+        assert client.get(f"{e2e_base_url}/get").http_version == "HTTP/1.1"
+
+    def test_http1_only_survives_reopen(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        client = httpr.Client(ca_cert_file=e2e_ca_cert, http1_only=True)
+        client.close()
+        with pytest.warns(httpr.ClientReopenedWarning):
+            response = client.get(f"{e2e_base_url}/get")
+        assert response.http_version == "HTTP/1.1"
+
+    @pytest.mark.asyncio
+    async def test_async_client(self, e2e_base_url: str, e2e_ca_cert: str) -> None:
+        async with httpr.AsyncClient(ca_cert_file=e2e_ca_cert) as client:
+            assert (await client.get(f"{e2e_base_url}/get")).http_version == "HTTP/2"
+        async with httpr.AsyncClient(ca_cert_file=e2e_ca_cert, http1_only=True) as client:
+            assert (await client.get(f"{e2e_base_url}/get")).http_version == "HTTP/1.1"

httpr-0.7.4/tests/unit/test_http_version.py

@@ -0,0 +1,48 @@
+"""`http1_only` and `response.http_version` (issue #113).
+
+pytest-httpbin only speaks HTTP/1.1, so these tests cover the plumbing; the
+HTTP/2 cases run against httpbun over TLS in tests/e2e/test_http_version.py.
+"""
+
+import pytest
+
+import httpr
+
+
+def test_http_version_buffered(base_url):
+    response = httpr.Client().get(f"{base_url}/get")
+    assert response.http_version == "HTTP/1.1"
+
+
+def test_http_version_over_tls_without_h2(base_url_ssl, ca_bundle):
+    """ALPN falls back to HTTP/1.1 when the server doesn't offer h2."""
+    response = httpr.Client(ca_cert_file=ca_bundle).get(f"{base_url_ssl}/get")
+    assert response.status_code == 200
+    assert response.http_version == "HTTP/1.1"
+
+
+def test_http_version_streaming(base_url):
+    with httpr.Client().stream("GET", f"{base_url}/get") as response:
+        assert response.http_version == "HTTP/1.1"
+
+
+@pytest.mark.asyncio
+async def test_http_version_async(base_url):
+    async with httpr.AsyncClient() as client:
+        response = await client.get(f"{base_url}/get")
+        assert response.http_version == "HTTP/1.1"
+        async with client.stream("GET", f"{base_url}/get") as streamed:
+            assert streamed.http_version == "HTTP/1.1"
+
+
+@pytest.mark.parametrize("client_cls", [httpr.Client, httpr.AsyncClient])
+def test_http1_only_accepted(base_url, client_cls):
+    client = client_cls(http1_only=True)
+    if client_cls is httpr.Client:
+        assert client.get(f"{base_url}/get").http_version == "HTTP/1.1"
+
+
+@pytest.mark.parametrize("client_cls", [httpr.Client, httpr.AsyncClient])
+def test_http1_only_and_http2_only_conflict(client_cls):
+    with pytest.raises(ValueError, match="http1_only or http2_only"):
+        client_cls(http1_only=True, http2_only=True)

{httpr-0.7.2 → httpr-0.7.4}/tests/unit/test_timeout.py

@@ -196,18 +196,20 @@ def test_timeout_survives_proxy_rebuild(slow):
 
 
 def test_slow_stream_is_not_cut_off(slow):
-    """Five chunks 0.3 s apart take 1.2 s in total, longer than the 0.5 s
-    timeout, but no single wait exceeds it."""
-    client = httpr.Client(timeout=0.5)
-    with client.stream("GET", f"{slow.url}/trickle/5/0.3") as response:
+    """Eight chunks 0.2 s apart take 1.4 s in total, longer than the 1 s
+    timeout, but no single wait exceeds it. The 5x margin per gap absorbs
+    sleep overshoot on slow CI runners (macOS overshoots by >100%); overshoot
+    only lengthens the total, so the body still outlasts the timeout."""
+    client = httpr.Client(timeout=1.0)
+    with client.stream("GET", f"{slow.url}/trickle/8/0.2") as response:
         chunks = list(response.iter_bytes())
-    assert b"".join(chunks) == b"".join(f"chunk{i}\n".encode() for i in range(5))
+    assert b"".join(chunks) == b"".join(f"chunk{i}\n".encode() for i in range(8))
 
 
 def test_slow_buffered_body_is_not_cut_off(slow):
-    client = httpr.Client(timeout=0.5)
-    response = client.get(f"{slow.url}/trickle/5/0.3")
-    assert response.text == "".join(f"chunk{i}\n" for i in range(5))
+    client = httpr.Client(timeout=1.0)
+    response = client.get(f"{slow.url}/trickle/8/0.2")
+    assert response.text == "".join(f"chunk{i}\n" for i in range(8))
 
 
 def test_stalled_stream_times_out(slow):
@@ -248,10 +250,10 @@ def test_stalled_stream_read_times_out(slow):
 
 @pytest.mark.asyncio
 async def test_async_slow_stream_is_not_cut_off(slow):
-    async with httpr.AsyncClient(timeout=0.5) as client:
-        async with client.stream("GET", f"{slow.url}/trickle/5/0.3") as response:
+    async with httpr.AsyncClient(timeout=1.0) as client:
+        async with client.stream("GET", f"{slow.url}/trickle/8/0.2") as response:
             lines = [line async for line in response.aiter_lines()]
-    assert lines == [f"chunk{i}\n" for i in range(5)]
+    assert lines == [f"chunk{i}\n" for i in range(8)]
 
 
 @pytest.mark.asyncio