httpr 0.7.1__tar.gz → 0.7.4__tar.gz

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

@@ -62,6 +62,53 @@ jobs:
           uv run task dev
           uv run task test:unit
 
+  # Downstream compatibility: pyvespa's unit suite against the wheel built from
+  # this commit. pyvespa is the main consumer of httpr and consumed lazy
+  # generators after `close()` for a year without anyone noticing, until 0.7.0
+  # made close() real. Runs on PRs, main branch, and tag pushes.
+  downstream-pyvespa:
+    runs-on: ubuntu-22.04
+    if: github.event_name == 'pull_request' || (github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')))
+    steps:
+      - uses: actions/checkout@v5
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: "3.12"
+      - name: Cache Rust build
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: rust-v2-${{ runner.os }}-downstream-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            rust-v2-${{ runner.os }}-downstream-
+      - name: Build wheel
+        run: uv run --with maturin maturin build --release --out dist
+      - name: Check out pyvespa master
+        uses: actions/checkout@v5
+        with:
+          repository: vespa-engine/pyvespa
+          ref: master
+          path: pyvespa
+      - name: Install pyvespa, then swap in this wheel
+        # pyvespa pins httpr>=0.4.0 and the local wheel is 0.0.0.dev0, so it
+        # cannot be part of the resolve; install it afterwards with --no-deps.
+        run: |
+          uv venv .venv-pyvespa
+          uv pip install --python .venv-pyvespa/bin/python "./pyvespa[unittest]"
+          uv pip install --python .venv-pyvespa/bin/python --no-deps --reinstall dist/httpr-*.whl
+          .venv-pyvespa/bin/python -c "import importlib.metadata as m; v = m.version('httpr'); assert v.startswith('0.0.0'), v; print('httpr', v)"
+      - name: pyvespa unit tests
+        # The venv's bin goes first on PATH: the deployment tests create a
+        # throwaway Vespa Cloud cert/key pair with the `vespa` CLI (from the
+        # `vespacli` package in pyvespa's unittest extra) and skip it otherwise.
+        working-directory: pyvespa
+        run: |
+          export PATH="$GITHUB_WORKSPACE/.venv-pyvespa/bin:$PATH"
+          python -m pytest tests/unit -q -p no:cacheprovider
+
   # E2E tests with httpbun Docker container - runs on PRs, main branch, and tag pushes
   e2e:
     runs-on: ubuntu-22.04
@@ -143,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
@@ -169,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: ""
@@ -202,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:
@@ -235,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.1 → 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
@@ -194,9 +200,10 @@ builds in debug mode and the numbers are meaningless.
 - Overlapping requests make hyper race a fresh connect against the idle-pool checkout; a losing connect is finished in the background and holds the pool alive until it resolves, which needs real I/O and against a remote host can take longer than `close()` should wait. So every `reqwest::Client` is built with `CancelConnectsLayer` (a tower layer over reqwest's connector, via `ClientBuilder::connector_layer`) and `close()` cancels the token when nothing is in flight; cancelled connects resolve on the next scheduler turn and drop their pool handle. Do not replace this with waiting or with `num_alive_tasks` heuristics: the count is runtime-global and a pending connect keeps it constant
 - `begin_request()` increments `in_flight` before cloning the `reqwest::Client`, so a request already in flight keeps the pool alive and finishes normally when the client is closed underneath it. While anything is in flight `close()` only drops its own handle and yields; the `InFlight` guard of the last request to finish (in `request()` after the body is buffered, or `StreamingResponse::close()`/drop for streams) cancels pending connects and settles. `StreamingResponse` owns its `InFlight` for its whole lifetime, since its connection stays busy until it is closed
 - `set_proxy` swaps the client via `ClientState::replace()` and settles the old pool; it raises `ClientClosed` on a closed client. `RClient` implements `Drop`, so a client garbage-collected without `close()` releases its pool as well (safe: every `block_on` in the crate runs with the GIL released, so dealloc never happens inside one)
-- Use after close raises `ClientClosed`, a `RuntimeError` subclass (httpx raises plain `RuntimeError` here); header/cookie getters keep working. `is_closed` getter mirrors httpx. The message lives once in Rust (`CLIENT_CLOSED_MSG`, exported as `_CLIENT_CLOSED_MSG`)
-- Python: `Client.close()`/`__exit__` call the Rust `close()`; `AsyncClient.aclose()`/`__aexit__` additionally `shutdown(wait=False)` the client's own `ThreadPoolExecutor`, and run on the event-loop thread on purpose (sub-millisecond, no I/O wait). `_run_sync_asyncio` checks `is_closed` first and also maps the executor's "cannot schedule new futures after shutdown" `RuntimeError` to `ClientClosed`, which covers a `close()` racing in from another OS thread
-- Leaving a `with`/`async with` block closes the client; re-entering it afterwards raises `ClientClosed` on the next request. pyvespa's `VespaSync`/`VespaAsync` given an external session never close it and are unaffected; with an owned client they close but never null it, so re-entering the same wrapper object raises `ClientClosed` (see memory note; needs a pyvespa-side fix)
+- Use after close reopens the client (since 0.7.2; `requests.Session` semantics): `RClient::begin_request` finds the slot empty, rebuilds the `reqwest::Client` via `ClientConfig::build()` with a fresh `CancellationToken`, installs it with `ClientState::reopen()` (the old token was cancelled by `close()` and must not be reused) and emits `ClientReopenedWarning`, a `ResourceWarning` subclass, so `warnings.simplefilter("error", httpr.ClientReopenedWarning)` gives httpx's strict behaviour. The rebuilt client starts with an empty cookie store; headers, params, auth, proxy and timeout live on `RClient` and carry over. `is_closed` is true from `close()` until the next request. `ClientClosed` (a `RuntimeError` subclass) stays exported but is only raised if a `close()` races the reopen. Both messages live once in Rust (`CLIENT_CLOSED_MSG`/`CLIENT_REOPENED_MSG`, exported as `_CLIENT_CLOSED_MSG`/`_CLIENT_REOPENED_MSG`). Do not go back to raising on use after close: every released pyvespa (`httpr>=0.4.0`) consumes `visit`/streaming-query generators after the owning `with VespaSync` block has closed the client, and 0.7.0/0.7.1 broke them all (pyvespa PR #1347 fixes the pattern going forward)
+- Python: `Client.close()`/`__exit__` call the Rust `close()`; `AsyncClient.aclose()`/`__aexit__` additionally `shutdown(wait=False)` the client's own `ThreadPoolExecutor` and drop it, and run on the event-loop thread on purpose (sub-millisecond, no I/O wait). The executor is created on demand by `_dispatch_executor()`, so a reopened client gets a new one; `_run_sync_asyncio` retries once on the executor's "cannot schedule new futures after shutdown" `RuntimeError`, which covers a `close()` racing in from another OS thread
+- Leaving a `with`/`async with` block closes the client; re-entering it afterwards works and warns once per reopen
+- CI runs pyvespa's unit suite (`origin/master`) against the wheel built from every PR (`downstream-pyvespa` job in `CI.yml`); it is the guard against this class of regression
 
 ### Timeouts (issue #81)
 - Default `timeout` is 30 s and lives in the PyO3 `#[new]` signature in `src/lib.rs`; `Client.__init__` in Python only documents the parameters and forwards nothing, so its defaults must match Rust's (`test_python_signature_matches_rust_defaults` enforces this). `None` disables the timeout

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpr
-Version: 0.7.1
+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`.
 
     """
 ```
@@ -170,7 +174,7 @@ finally:
     client.close()  # idempotent
 ```
 
-Requests that are still in flight when `close()` is called (including open `stream()` responses) finish normally; the pool is released as soon as the last of them completes. Any request made afterwards, or assigning `client.proxy`, raises `httpr.ClientClosed` (a `RuntimeError`, as in httpx); `client.is_closed` tells you which state a client is in. `AsyncClient` offers the same via `aclose()` / `async with`, and additionally shuts down its own thread pool. A client that is garbage-collected without being closed releases its pool too, but only once the interpreter gets to it, so prefer closing explicitly.
+Requests that are still in flight when `close()` is called (including open `stream()` responses) finish normally; the pool is released as soon as the last of them completes. A request made afterwards reopens the client with a fresh pool, the way a `requests.Session` does, and emits `httpr.ClientReopenedWarning` (a `ResourceWarning`, silent by default). Run with `-W error::httpr.ClientReopenedWarning` or `warnings.simplefilter("error", httpr.ClientReopenedWarning)` to get httpx's strict use-after-close behaviour instead. `client.is_closed` tells you which state a client is in. `AsyncClient` offers the same via `aclose()` / `async with`, and additionally shuts down its own thread pool. A client that is garbage-collected without being closed releases its pool too, but only once the interpreter gets to it, so prefer closing explicitly.
 
 #### Client methods
 

{httpr-0.7.1 → 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`.
 
     """
 ```
@@ -126,7 +130,7 @@ finally:
     client.close()  # idempotent
 ```
 
-Requests that are still in flight when `close()` is called (including open `stream()` responses) finish normally; the pool is released as soon as the last of them completes. Any request made afterwards, or assigning `client.proxy`, raises `httpr.ClientClosed` (a `RuntimeError`, as in httpx); `client.is_closed` tells you which state a client is in. `AsyncClient` offers the same via `aclose()` / `async with`, and additionally shuts down its own thread pool. A client that is garbage-collected without being closed releases its pool too, but only once the interpreter gets to it, so prefer closing explicitly.
+Requests that are still in flight when `close()` is called (including open `stream()` responses) finish normally; the pool is released as soon as the last of them completes. A request made afterwards reopens the client with a fresh pool, the way a `requests.Session` does, and emits `httpr.ClientReopenedWarning` (a `ResourceWarning`, silent by default). Run with `-W error::httpr.ClientReopenedWarning` or `warnings.simplefilter("error", httpr.ClientReopenedWarning)` to get httpx's strict use-after-close behaviour instead. `client.is_closed` tells you which state a client is in. `AsyncClient` offers the same via `aclose()` / `async with`, and additionally shuts down its own thread pool. A client that is garbage-collected without being closed releases its pool too, but only once the interpreter gets to it, so prefer closing explicitly.
 
 #### Client methods
 

{httpr-0.7.1 → 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.1 → 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.1 → 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.1 → 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
@@ -635,7 +653,7 @@ async with httpr.AsyncClient() as client:
             handle(line)
 ```
 
-The synchronous `iter_bytes()`, `iter_text()`, `iter_lines()` and `read()` remain available on the async response but block the event loop until the next chunk arrives; prefer the `a`-prefixed methods in async code. After `client.aclose()`, the next async step raises `httpr.ClientClosed`.
+The synchronous `iter_bytes()`, `iter_text()`, `iter_lines()` and `read()` remain available on the async response but block the event loop until the next chunk arrives; prefer the `a`-prefixed methods in async code. A stream that is open when `client.aclose()` is called keeps its connection and can still be read to the end.
 
 ---
 

{httpr-0.7.1 → 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.1 → httpr-0.7.4}/httpr/__init__.py

@@ -42,9 +42,9 @@ else:
 
 
 from .httpr import (
-    _CLIENT_CLOSED_MSG,
     CaseInsensitiveHeaderMap,
     ClientClosed,
+    ClientReopenedWarning,
     RClient,
     Response,
     StreamingResponse,
@@ -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
@@ -308,9 +314,11 @@ class Client(RClient):
         Idle pooled connections are shut down before this returns. Requests
         that are already in flight (including open `stream()` responses) finish
         normally and keep the pool alive until the last of them completes, at
-        which point it is released. Any request made after `close()` raises
-        `httpr.ClientClosed` (a `RuntimeError`, as in httpx). Calling `close()`
-        more than once is a no-op.
+        which point it is released. A request made after `close()` reopens the
+        client with a fresh connection pool and emits
+        `httpr.ClientReopenedWarning` (a `ResourceWarning`, silent by default);
+        turn it into an error with the `warnings` module to get httpx's strict
+        behaviour instead. Calling `close()` more than once is a no-op.
 
         Example:
             ```python
@@ -684,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."""
@@ -738,8 +751,8 @@ class AsyncStreamingResponse:
 
     async def _aiter(self, it: Iterator[_T]) -> AsyncIterator[_T]:
         # Each `next()` does a blocking read on the Rust side, so it goes through
-        # the client's executor like a request does. `_run_sync_asyncio` maps a
-        # closed client to ClientClosed.
+        # the client's executor like a request does. The stream holds its own
+        # handle to the pool, so it keeps reading after the client is closed.
         sentinel: object = object()
         while True:
             item = await self._client._run_sync_asyncio(next, it, sentinel)
@@ -896,12 +909,10 @@ class AsyncClient(Client):
         """
         super().__init__(*args, **kwargs)
         self.max_concurrency = max_concurrency
-        # Threads are created on demand; `close()`/`aclose()` shut the pool down.
-        self._executor = (
-            None
-            if max_concurrency is None
-            else ThreadPoolExecutor(max_workers=max_concurrency, thread_name_prefix="httpr")
-        )
+        # Created on first use by `_dispatch_executor()`; `close()`/`aclose()`
+        # shut it down and drop it, and the next request creates a new one, so
+        # a client reopened after close gets its threads back as well.
+        self._executor: ThreadPoolExecutor | None = None
 
     async def __aenter__(self) -> AsyncClient:
         """Enter async context manager."""
@@ -920,19 +931,21 @@ class AsyncClient(Client):
         the `Client` contract too.
         """
         super().close()
-        if self._executor is not None:
+        executor, self._executor = self._executor, None
+        if executor is not None:
             # Requests still running on the pool keep their handle to the reqwest
-            # client and finish normally; queued ones raise ClientClosed when they
-            # run. Not waiting keeps this safe to call from the event-loop thread.
-            self._executor.shutdown(wait=False)
+            # client and finish normally. Not waiting keeps this safe to call
+            # from the event-loop thread.
+            executor.shutdown(wait=False)
 
     async def aclose(self) -> None:
         """
         Close the async client.
 
         Releases the connection pool and shuts down this client's thread pool.
-        Any request made after `aclose()` raises `httpr.ClientClosed`. Calling it
-        more than once is a no-op.
+        A request made after `aclose()` reopens both, with a
+        `httpr.ClientReopenedWarning` (see `Client.close()`). Calling it more
+        than once is a no-op.
 
         Example:
             ```python
@@ -948,24 +961,25 @@ class AsyncClient(Client):
         # millisecond, less than a hop through the executor would cost.
         self.close()
 
+    def _dispatch_executor(self) -> ThreadPoolExecutor | None:
+        """This client's thread pool, created on demand; `None` means asyncio's default."""
+        if self.max_concurrency is None:
+            return None
+        if self._executor is None:
+            self._executor = ThreadPoolExecutor(max_workers=self.max_concurrency, thread_name_prefix="httpr")
+        return self._executor
+
     async def _run_sync_asyncio(self, fn, *args, **kwargs):
         """Run a synchronous function on this client's executor."""
-        if self.is_closed:
-            # Checked here rather than left to the Rust side so a closed client
-            # raises ClientClosed instead of the executor's own "cannot schedule
-            # new futures after shutdown" RuntimeError.
-            raise ClientClosed(_CLIENT_CLOSED_MSG)
         loop = asyncio.get_running_loop()
+        call = partial(fn, *args, **kwargs)
         try:
-            future = loop.run_in_executor(self._executor, partial(fn, *args, **kwargs))
+            future = loop.run_in_executor(self._dispatch_executor(), call)
         except RuntimeError:
-            # The executor is only ever shut down by close()/aclose(), so if one
-            # landed between the check above and submit (from another thread),
-            # report it as the client being closed rather than leaking the
-            # executor's own error.
-            if self.is_closed:
-                raise ClientClosed(_CLIENT_CLOSED_MSG) from None
-            raise
+            # A close() from another thread shut the pool down between the lookup
+            # and the submit. The client reopens on use, so does its executor.
+            self._executor = None
+            future = loop.run_in_executor(self._dispatch_executor(), call)
         return await future
 
     async def request(  # type: ignore[override]
@@ -1463,6 +1477,7 @@ __all__ = [
     "StreamClosed",
     # Client lifecycle exceptions
     "ClientClosed",
+    "ClientReopenedWarning",
     "InvalidURL",
     "CookieConflict",
 ]