httpr 0.7.1__tar.gz → 0.7.2__tar.gz

{httpr-0.7.1 → httpr-0.7.2}/.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

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

@@ -194,9 +194,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.2}/Cargo.lock

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpr
-Version: 0.7.1
+Version: 0.7.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -170,7 +170,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.2}/README.md

@@ -126,7 +126,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.2}/docs/api/response.md

@@ -635,7 +635,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.2}/httpr/__init__.py

@@ -42,9 +42,9 @@ else:
 
 
 from .httpr import (
-    _CLIENT_CLOSED_MSG,
     CaseInsensitiveHeaderMap,
     ClientClosed,
+    ClientReopenedWarning,
     RClient,
     Response,
     StreamingResponse,
@@ -308,9 +308,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
@@ -738,8 +740,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 +898,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 +920,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 +950,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 +1466,7 @@ __all__ = [
     "StreamClosed",
     # Client lifecycle exceptions
     "ClientClosed",
+    "ClientReopenedWarning",
     "InvalidURL",
     "CookieConflict",
 ]

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

@@ -512,7 +512,8 @@ class Client(RClient):
         """
         Close the client and release its connection pool.
 
-        Requests made after `close()` raise `ClientClosed`. Idempotent.
+        A request made after `close()` reopens the client with a fresh pool and
+        emits `ClientReopenedWarning`. Idempotent.
         """
         ...
     def stream(
@@ -608,7 +609,8 @@ class AsyncClient(Client):
         """
         Close the async client and shut down its thread pool.
 
-        Requests made after `aclose()` raise `ClientClosed`. Idempotent.
+        A request made after `aclose()` reopens both and emits
+        `ClientReopenedWarning`. Idempotent.
         """
         ...
     async def request(  # type: ignore[override]
@@ -763,9 +765,16 @@ class StreamClosed(StreamError):
 
 # Client lifecycle exceptions
 class ClientClosed(RuntimeError):
-    """Attempted to use a client after `close()` was called."""
+    """A request could not start because `close()` raced it.
+
+    Rare since 0.7.2: a request on a closed client reopens it instead.
+    """
+
+class ClientReopenedWarning(ResourceWarning):
+    """A request was made on a closed client, which was reopened with a fresh connection pool."""
 
 _CLIENT_CLOSED_MSG: str
+_CLIENT_REOPENED_MSG: str
 
 # Other exceptions
 class InvalidURL(Exception):
@@ -832,6 +841,7 @@ __all__ = [
     "StreamClosed",
     # Client lifecycle exceptions
     "ClientClosed",
+    "ClientReopenedWarning",
     # Other exceptions
     "InvalidURL",
     "CookieConflict",

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

{httpr-0.7.1 → httpr-0.7.2}/src/exceptions.rs

@@ -1,5 +1,5 @@
 use pyo3::create_exception;
-use pyo3::exceptions::{PyException, PyRuntimeError};
+use pyo3::exceptions::{PyException, PyResourceWarning, PyRuntimeError};
 use pyo3::prelude::*;
 
 use crate::timeout::TimedOut;
@@ -184,7 +184,13 @@ create_exception!(
     httpr,
     ClientClosed,
     PyRuntimeError,
-    "Attempted to use a client after `close()` was called. Subclasses RuntimeError, matching httpx."
+    "Raised when a request cannot be started because the client was closed underneath it. Subclasses RuntimeError, matching httpx. Since 0.7.2 a request on a closed client reopens it instead (see `ClientReopenedWarning`), so this is only seen when `close()` races the request itself."
+);
+create_exception!(
+    httpr,
+    ClientReopenedWarning,
+    PyResourceWarning,
+    "A request was made on a client after `close()`; the client was reopened with a fresh connection pool. Filter this warning with `error` to make use-after-close raise instead."
 );
 
 // Other exceptions
@@ -405,6 +411,10 @@ pub fn register_exceptions(m: &Bound<'_, PyModule>) -> PyResult<()> {
 
     // Client lifecycle exceptions
     m.add("ClientClosed", m.py().get_type::<ClientClosed>())?;
+    m.add(
+        "ClientReopenedWarning",
+        m.py().get_type::<ClientReopenedWarning>(),
+    )?;
 
     // Other exceptions
     m.add("InvalidURL", m.py().get_type::<InvalidURL>())?;

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

@@ -1,4 +1,5 @@
 #![allow(clippy::too_many_arguments)]
+use std::ffi::CStr;
 use std::sync::{Arc, LazyLock, Mutex};
 use std::time::Duration;
 use std::{fs, str};
@@ -38,7 +39,7 @@ mod utils;
 use utils::load_ca_certs;
 
 mod exceptions;
-use exceptions::{map_anyhow_error, map_reqwest_error, ClientClosed};
+use exceptions::{map_anyhow_error, map_reqwest_error, ClientClosed, ClientReopenedWarning};
 
 mod lifecycle;
 use lifecycle::ClientState;
@@ -58,6 +59,7 @@ static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
 
 /// Error message for any operation on a client after `close()`; mirrors httpx.
 const CLIENT_CLOSED_MSG: &str = "Cannot send a request, as the client has been closed.";
+const CLIENT_REOPENED_MSG: &CStr = c"Request made on a closed httpr client; reopening it with a fresh connection pool. Keep the client open for as long as it is used (a generator or stream created inside a `with` block runs after the block has closed the client).";
 
 /// The constructor settings a rebuilt `reqwest::Client` has to carry over, so
 /// that assigning `client.proxy` keeps TLS verification, the CA bundle, the
@@ -150,8 +152,40 @@ pub struct RClient {
 
 impl RClient {
     /// A handle to the underlying `reqwest::Client` plus the in-flight guard
-    /// for one request, or `ClientClosed` if `close()` has been called.
-    fn begin_request(&self) -> PyResult<(reqwest::Client, lifecycle::InFlight)> {
+    /// for one request.
+    ///
+    /// On a closed client this rebuilds the `reqwest::Client` from the
+    /// constructor settings, installs it with a fresh cancellation token and
+    /// emits `ClientReopenedWarning`, so a request after `close()` works the
+    /// way it does on a `requests.Session`. Under `warnings.simplefilter("error")`
+    /// the warning is raised instead and no request is sent. The rebuilt client
+    /// starts with an empty cookie store; default headers, params, auth, proxy
+    /// and timeout live on the `RClient` and carry over.
+    fn begin_request(&self, py: Python<'_>) -> PyResult<(reqwest::Client, lifecycle::InFlight)> {
+        if let Some(started) = self.state.begin_request() {
+            return Ok(started);
+        }
+        let default_headers = self
+            .headers
+            .lock()
+            .map_err(|e| map_anyhow_error(anyhow!("Failed to acquire headers lock: {}", e)))?
+            .clone();
+        let connects = CancellationToken::new();
+        let client = self.config.build(
+            lifecycle::CancelConnectsLayer::new(connects.clone()),
+            default_headers,
+            self.proxy.as_deref(),
+        )?;
+        // Losing to a concurrent reopen is fine: the slot is filled either way
+        // and the unused client here never had a connection to release.
+        self.state.reopen(client, connects);
+        PyErr::warn(
+            py,
+            &py.get_type::<ClientReopenedWarning>(),
+            CLIENT_REOPENED_MSG,
+            2,
+        )?;
+        // Only a `close()` racing in between can still leave this empty.
         self.state
             .begin_request()
             .ok_or_else(|| ClientClosed::new_err(CLIENT_CLOSED_MSG))
@@ -579,7 +613,8 @@ impl RClient {
     /// is dropped and its idle connections are released; a connect the old
     /// pool still had pending in the background is left to resolve on its own
     /// (it is torn down the next time the runtime is driven). Raises
-    /// `ClientClosed` on a closed client.
+    /// On a closed client only the proxy is recorded; the request that reopens
+    /// the client builds with it.
     #[setter]
     pub fn set_proxy(&mut self, py: Python, proxy: Option<String>) -> PyResult<()> {
         let default_headers = self
@@ -592,14 +627,15 @@ impl RClient {
             default_headers,
             proxy.as_deref(),
         )?;
-        if !py.detach(|| self.state.replace(new_client)) {
-            return Err(ClientClosed::new_err(CLIENT_CLOSED_MSG));
-        }
+        // On a closed client there is nothing to swap; the proxy is recorded
+        // and the rebuild on the next request picks it up.
+        py.detach(|| self.state.replace(new_client));
         self.proxy = proxy;
         Ok(())
     }
 
-    /// Whether `close()` has been called on this client.
+    /// Whether the client is currently closed: `close()` has been called and no
+    /// request has reopened it since.
     #[getter]
     pub fn is_closed(&self) -> bool {
         self.state.is_closed()
@@ -612,8 +648,9 @@ impl RClient {
     /// returns. Requests already in flight hold their own handle to the pool
     /// and finish normally; while any of them is running the pool, including
     /// its idle connections, stays alive, and the last one to finish releases
-    /// it. Any later request on this client raises `ClientClosed`. Calling
-    /// `close()` more than once is a no-op.
+    /// it. A later request on this client reopens it with a fresh pool and
+    /// emits `ClientReopenedWarning` (see `begin_request`). Calling `close()`
+    /// more than once is a no-op.
     pub fn close(&self, py: Python) {
         py.detach(|| self.state.close());
     }
@@ -672,7 +709,7 @@ impl RClient {
         auth_bearer: Option<String>,
         timeout: Option<f64>,
     ) -> PyResult<Response> {
-        let (client, in_flight) = self.begin_request()?;
+        let (client, in_flight) = self.begin_request(py)?;
         let (builder, timeout) = self.build_request(
             client,
             method,
@@ -767,7 +804,7 @@ impl RClient {
         auth_bearer: Option<String>,
         timeout: Option<f64>,
     ) -> PyResult<StreamingResponse> {
-        let (client, in_flight) = self.begin_request()?;
+        let (client, in_flight) = self.begin_request(py)?;
         let (builder, timeout) = self.build_request(
             client,
             method,
@@ -828,6 +865,10 @@ fn httpr(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<TextIterator>()?;
     m.add_class::<LineIterator>()?;
     m.add("_CLIENT_CLOSED_MSG", CLIENT_CLOSED_MSG)?;
+    m.add(
+        "_CLIENT_REOPENED_MSG",
+        CLIENT_REOPENED_MSG.to_str().expect("message is ASCII"),
+    )?;
 
     // Register all exception types
     exceptions::register_exceptions(m)?;

{httpr-0.7.1 → httpr-0.7.2}/src/lifecycle.rs

@@ -28,6 +28,13 @@
 //! A client that never started a request has nothing to release: its pool
 //! holds no connection and its connector has no connect pending, so closing
 //! or dropping it skips the whole procedure.
+//!
+//! A closed client is not dead. A request made after `close()` rebuilds the
+//! `reqwest::Client` from the constructor settings and carries on with a fresh
+//! pool (`requests.Session` semantics), after warning. [`ClientState::reopen`]
+//! installs the rebuilt client together with a new cancellation token, since
+//! the old token was cancelled by the close and would kill every connect of the
+//! new pool on sight.
 
 use std::fmt;
 use std::future::Future;
@@ -83,8 +90,9 @@ pub struct ClientState {
     /// Whether any request was ever started. Until then the pool cannot hold a
     /// connection or a pending connect, so there is nothing to release.
     used: AtomicBool,
-    /// Cancels every connect still pending in the pool's connector.
-    connects: CancellationToken,
+    /// Cancels every connect still pending in the pool's connector. Replaced
+    /// together with the client on [`ClientState::reopen`].
+    connects: Mutex<CancellationToken>,
 }
 
 impl ClientState {
@@ -95,14 +103,19 @@ impl ClientState {
             client: Mutex::new(Some(client)),
             in_flight: AtomicUsize::new(0),
             used: AtomicBool::new(false),
-            connects,
+            connects: Mutex::new(connects),
         })
     }
 
-    /// The layer to install on any `reqwest::ClientBuilder` whose client will
-    /// live in this state, so `close()` can cancel its pending connects.
+    /// The layer to install on a `reqwest::ClientBuilder` whose client will
+    /// replace the current one via [`ClientState::replace`], so `close()` can
+    /// cancel its pending connects.
     pub fn connector_layer(&self) -> CancelConnectsLayer {
-        CancelConnectsLayer(self.connects.clone())
+        CancelConnectsLayer(self.token().clone())
+    }
+
+    fn token(&self) -> MutexGuard<'_, CancellationToken> {
+        self.connects.lock().unwrap_or_else(|e| e.into_inner())
     }
 
     /// The slot holding the client. A poisoned lock is recovered rather than
@@ -151,6 +164,24 @@ impl ClientState {
         true
     }
 
+    /// Bring a closed client back with a rebuilt `reqwest::Client`. `connects`
+    /// must be the fresh token its [`CancelConnectsLayer`] was created from; the
+    /// previous token was cancelled by `close()` and must not be reused. Returns
+    /// `false`, leaving `new` unused, if the client is open (another thread
+    /// reopened it first, or it was never closed).
+    pub fn reopen(&self, new: reqwest::Client, connects: CancellationToken) -> bool {
+        let mut slot = self.slot();
+        if slot.is_some() {
+            return false;
+        }
+        *slot = Some(new);
+        *self.token() = connects;
+        // The new pool has no connection and nothing pending; `used` describes
+        // the pool in the slot, so it starts over.
+        self.used.store(false, Ordering::SeqCst);
+        true
+    }
+
     /// Close the client. Returns `false` if it was already closed.
     pub fn close(&self) -> bool {
         let Some(client) = self.slot().take() else {
@@ -174,7 +205,7 @@ impl ClientState {
             // alive. With requests in flight this is skipped: their connects
             // must not be interrupted, and the last of them to finish will
             // cancel instead (see `InFlight`).
-            self.connects.cancel();
+            self.token().cancel();
         }
         settle_dropped_pool();
     }

{httpr-0.7.1 → httpr-0.7.2}/tests/unit/test_asyncclient.py

@@ -32,12 +32,12 @@ async def test_asyncclient_init(base_url_ssl, ca_bundle):
 def test_default_max_concurrency():
     client = httpr.AsyncClient()
     assert client.max_concurrency == httpr.DEFAULT_MAX_CONCURRENCY
-    assert client._executor._max_workers == httpr.DEFAULT_MAX_CONCURRENCY
+    assert client._dispatch_executor()._max_workers == httpr.DEFAULT_MAX_CONCURRENCY
 
 
 def test_max_concurrency_sizes_the_pool():
     client = httpr.AsyncClient(max_concurrency=7)
-    assert client._executor._max_workers == 7
+    assert client._dispatch_executor()._max_workers == 7
 
 
 @pytest.mark.asyncio
@@ -55,7 +55,7 @@ async def test_requests_run_on_the_clients_own_pool(base_url):
 @pytest.mark.asyncio
 async def test_max_concurrency_none_uses_default_executor():
     client = httpr.AsyncClient(max_concurrency=None)
-    assert client._executor is None
+    assert client._dispatch_executor() is None
     thread_name = await client._run_sync_asyncio(lambda: threading.current_thread().name)
     assert thread_name.startswith("asyncio_")
 
@@ -97,15 +97,12 @@ async def test_concurrency_is_not_capped_by_the_default_executor():
 
 
 @pytest.mark.asyncio
-async def test_client_is_reusable_until_closed(base_url):
-    """One client serves many requests; leaving `async with` closes it (issue #88).
-
-    This replaces a test that asserted the opposite -- that a client kept working
-    after `aclose()` and across repeated `async with` blocks -- which only held
-    because `aclose()` used to be a no-op. Downstream wrappers that own their
-    httpr client and re-enter the same wrapper object (pyvespa's VespaSync /
-    VespaAsync without an external session) now see ClientClosed on the second
-    entry; wrappers given an external client never close it and are unaffected.
+async def test_client_is_reusable_across_context_blocks(base_url):
+    """Leaving `async with` closes the client (issue #88); using it again reopens it.
+
+    0.7.0 and 0.7.1 raised ClientClosed here, which broke every released pyvespa
+    (VespaSync/VespaAsync re-enter the same wrapper, and `visit()` generators
+    run after the block). Since 0.7.2 the request reopens the client and warns.
     See tests/unit/test_close.py for the full contract.
     """
     client = httpr.AsyncClient(max_concurrency=2)
@@ -114,7 +111,9 @@ async def test_client_is_reusable_until_closed(base_url):
 
     async with client:
         assert (await client.get(f"{base_url}/anything")).status_code == 200
+    assert client.is_closed
 
+    with pytest.warns(httpr.ClientReopenedWarning):
+        async with client:
+            assert (await client.get(f"{base_url}/anything")).status_code == 200
     assert client.is_closed
-    with pytest.raises(httpr.ClientClosed):
-        await client.get(f"{base_url}/anything")

{httpr-0.7.1 → httpr-0.7.2}/tests/unit/test_close.py

@@ -11,6 +11,7 @@ import asyncio
 import gc
 import threading
 import time
+import warnings
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 import pytest
@@ -129,29 +130,73 @@ def test_context_manager_exit_releases_pooled_connections(server):
     assert server.wait_for_open_connections(0), "__exit__ must release the pooled connection"
 
 
-def test_request_after_close_raises_client_closed(server):
+def test_request_after_close_reopens_with_warning(server):
+    """Use after close reopens the client with a fresh pool (requests.Session semantics)."""
     client = httpr.Client()
     client.get(server.url)
     client.close()
+    assert server.wait_for_open_connections(0)
 
-    with pytest.raises(httpr.ClientClosed, match="client has been closed"):
-        client.get(server.url)
-    with pytest.raises(httpr.ClientClosed):
-        client.request("GET", server.url)
-    with pytest.raises(httpr.ClientClosed):
-        with client.stream("GET", server.url):
-            pass
+    with pytest.warns(httpr.ClientReopenedWarning, match="reopening"):
+        assert client.get(server.url).status_code == 200
+    assert client.is_closed is False
+    assert server.wait_for_open_connections(1), "the reopened client pools its connection again"
 
-    # Nothing reached the server.
-    assert server.requests_served == 1
+    # Only the request that reopens warns; the client is open again afterwards.
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        assert client.request("GET", server.url).status_code == 200
+        with client.stream("GET", server.url) as response:
+            assert response.status_code == 200
+    assert server.requests_served == 4
+
+    client.close()
+    assert client.is_closed
+    assert server.wait_for_open_connections(0), "close() releases the reopened pool as well"
 
 
-def test_client_closed_is_a_runtime_error(server):
-    """httpx raises RuntimeError on use-after-close; code written for it keeps working."""
+def test_stream_after_close_reopens(server):
     client = httpr.Client()
     client.close()
-    with pytest.raises(RuntimeError):
-        client.get(server.url)
+    with pytest.warns(httpr.ClientReopenedWarning):
+        with client.stream("GET", server.url) as response:
+            assert response.read()
+    assert not client.is_closed
+
+
+def test_generator_consumed_after_with_block(server):
+    """The pyvespa pattern: a lazy generator created inside `with`, consumed after it.
+
+    Every released pyvespa does this in `Vespa.visit()`; 0.7.0 and 0.7.1 broke it.
+    """
+
+    def pages(client):
+        for _ in range(3):
+            yield client.get(server.url).status_code
+
+    with httpr.Client() as client:
+        gen = pages(client)
+    assert client.is_closed
+    with pytest.warns(httpr.ClientReopenedWarning):
+        assert list(gen) == [200, 200, 200]
+
+
+def test_reopened_warning_can_be_made_an_error(server):
+    """Filtering the warning as an error restores httpx's strict use-after-close."""
+    client = httpr.Client()
+    client.get(server.url)
+    client.close()
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", httpr.ClientReopenedWarning)
+        with pytest.raises(httpr.ClientReopenedWarning):
+            client.get(server.url)
+    assert server.requests_served == 1, "no request is sent when the warning is an error"
+
+
+def test_reopened_warning_is_a_resource_warning():
+    assert issubclass(httpr.ClientReopenedWarning, ResourceWarning)
+    # Kept for code written against 0.7.0/0.7.1.
+    assert issubclass(httpr.ClientClosed, RuntimeError)
 
 
 def test_close_is_idempotent(server):
@@ -171,20 +216,27 @@ def test_is_closed_property():
     assert client.is_closed is True
 
 
-def test_close_never_used_client():
+def test_close_never_used_client(server):
     client = httpr.Client()
     client.close()
     assert client.is_closed
     client.close()  # still a no-op
-    with pytest.raises(httpr.ClientClosed):
-        client.get("http://127.0.0.1:9/")
+    with pytest.warns(httpr.ClientReopenedWarning):
+        assert client.get(server.url).status_code == 200
 
 
-def test_proxy_setter_after_close_raises():
+def test_proxy_setter_after_close_applies_on_reopen(server):
+    """Assigning the proxy on a closed client is recorded and used by the rebuild."""
     client = httpr.Client()
+    client.get(server.url)
     client.close()
-    with pytest.raises(httpr.ClientClosed):
-        client.proxy = "http://127.0.0.1:1"
+    client.proxy = "http://127.0.0.1:1"
+    assert client.is_closed, "assigning a proxy does not reopen the client by itself"
+    assert client.proxy == "http://127.0.0.1:1"
+    with pytest.warns(httpr.ClientReopenedWarning), pytest.raises(httpr.HTTPError):
+        client.get(server.url)  # nothing listens on port 1
+    client.proxy = None
+    assert client.get(server.url).status_code == 200
 
 
 def test_headers_still_readable_after_close():
@@ -289,10 +341,12 @@ async def test_aclose_releases_connections_and_shuts_down_executor(server):
     assert (await client.get(server.url)).status_code == 200
     assert server.wait_for_open_connections(1)
 
+    executor = client._executor
     await client.aclose()
 
     assert client.is_closed
-    assert client._executor._shutdown, "aclose() must shut down the client's own thread pool"
+    assert executor._shutdown, "aclose() must shut down the client's own thread pool"
+    assert client._executor is None
     assert server.wait_for_open_connections(0)
 
 
@@ -303,22 +357,27 @@ async def test_async_context_manager_exit_closes(server):
         assert server.wait_for_open_connections(1)
 
     assert client.is_closed
-    assert client._executor._shutdown
+    assert client._executor is None
     assert server.wait_for_open_connections(0)
 
 
 @pytest.mark.asyncio
-async def test_async_request_after_aclose_raises_client_closed(server):
-    client = httpr.AsyncClient()
+async def test_async_request_after_aclose_reopens(server):
+    client = httpr.AsyncClient(max_concurrency=4)
     await client.get(server.url)
     await client.aclose()
 
-    with pytest.raises(httpr.ClientClosed, match="client has been closed"):
-        await client.get(server.url)
-    with pytest.raises(httpr.ClientClosed):
-        async with client.stream("GET", server.url):
-            pass
-    assert server.requests_served == 1
+    with pytest.warns(httpr.ClientReopenedWarning):
+        assert (await client.get(server.url)).status_code == 200
+    assert not client.is_closed
+    assert client._executor is not None and not client._executor._shutdown, "a new thread pool"
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        async with client.stream("GET", server.url) as response:
+            assert await response.aread()
+    assert server.requests_served == 3
+    await client.aclose()
+    assert server.wait_for_open_connections(0)
 
 
 @pytest.mark.asyncio
@@ -330,12 +389,12 @@ async def test_aclose_is_idempotent():
 
 
 @pytest.mark.asyncio
-async def test_aclose_never_used_client():
+async def test_aclose_never_used_client(server):
     client = httpr.AsyncClient()
     await client.aclose()
     assert client.is_closed
-    with pytest.raises(httpr.ClientClosed):
-        await client.get("http://127.0.0.1:9/")
+    with pytest.warns(httpr.ClientReopenedWarning):
+        assert (await client.get(server.url)).status_code == 200
 
 
 @pytest.mark.asyncio

{httpr-0.7.1 → httpr-0.7.2}/tests/unit/test_proxy.py

@@ -130,8 +130,10 @@ def test_client_identity_survives_rebuild(tmp_path):
     client.proxy = "http://127.0.0.1:1"
 
 
-def test_proxy_setter_after_close_raises_client_closed():
-    client = httpr.Client()
+def test_proxy_setter_after_close_is_recorded():
+    """A closed client has no reqwest client to rebuild; the proxy is kept for the reopen."""
+    client = httpr.Client(proxy="http://127.0.0.1:1")
     client.close()
-    with pytest.raises(httpr.ClientClosed):
-        client.proxy = None
+    client.proxy = None
+    assert client.proxy is None
+    assert client.is_closed

{httpr-0.7.1 → httpr-0.7.2}/tests/unit/test_streaming.py

@@ -343,14 +343,14 @@ class TestStreamingAsyncClient:
                 async with client.stream("INVALID", f"{base_url_ssl}/get") as _:  # type: ignore[arg-type]
                     pass
 
-    async def test_async_stream_after_close_raises_client_closed(self, base_url_ssl, ca_bundle):
-        """Once the client is closed, async iteration reports ClientClosed."""
+    async def test_async_stream_survives_client_close(self, base_url_ssl, ca_bundle):
+        """An open stream holds its own handle to the pool and reads to the end after aclose()."""
         client = httpr.AsyncClient(ca_cert_file=ca_bundle)
         async with client.stream("GET", f"{base_url_ssl}/html") as response:
             await client.aclose()
-            with pytest.raises(httpr.ClientClosed):
-                async for _ in response.aiter_bytes():
-                    pass
+            body = b"".join([chunk async for chunk in response.aiter_bytes()])
+        assert b"<html" in body.lower()
+        assert client.is_closed, "reading an in-flight stream does not reopen the client"
 
     # -- Issue #85: iteration must not block the event loop ---------------------