websocket-rs 0.7.2__tar.gz → 0.7.4__tar.gz

{websocket_rs-0.7.2 → websocket_rs-0.7.4}/.github/workflows/test.yml

@@ -55,7 +55,10 @@ jobs:
           uv venv --python ${{ matrix.python-version }}
 
       - name: Install dependencies with uv
-        run: uv pip install maturin pytest websockets
+        # uvloop has no Windows wheels; without it the uvloop half of the
+        # peer-close matrix silently drops, and uvloop+wss is a combination
+        # that actually regressed once.
+        run: uv pip install maturin pytest websockets "uvloop; sys_platform != 'win32'"
 
       - name: Build
         run: uv run maturin develop --release

{websocket_rs-0.7.2 → websocket_rs-0.7.4}/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.4] - 2026-07-29
+
+### Fixed
+
+- **`__version__` reported 0.7.1 (#TBD)**: the Python package hard-coded a version literal that was never bumped, so `websocket_rs.__version__` read `0.7.1` through the 0.7.2 and 0.7.3 releases while the installed distribution said otherwise. It now derives from the compiled module's `CARGO_PKG_VERSION`, leaving `Cargo.toml` as the single place a version is written by hand (`pyproject.toml` still mirrors it for the build backend).
+
+- **`eof_received` on the native protocol (#TBD)**: `NativeClient` implements asyncio's protocol callbacks by hand — it is a pyclass and inherits nothing from `asyncio.Protocol`, so the base class's default was never available — and `eof_received` was missing. When the peer half-closes, the transport calls it unguarded and the resulting `AttributeError` was raised inside asyncio's own callback: CPython routes it into `_fatal_error` ("Fatal error: protocol.eof_received() call failed."), so it surfaced as a connection error rather than a warning.
+
+  Affects every combination except plain TCP under uvloop, whose `_on_eof` is the only call site that guards with `try/except AttributeError`. Both TLS stacks (CPython `sslproto._call_eof_received`, uvloop `sslproto.pyx` `_call_eof_received`) call it directly, so `wss://` was affected under both event loops. Client-closes-first tests never reach this path, which is why it went unnoticed.
+
+  `NativeClientBuffered` inherits the fix. The regression test lives in `tests/test_timeout_and_errors.py` (one of the two files CI actually runs) and covers the loop × transport matrix; CI now installs uvloop everywhere it has wheels, so `uvloop + wss` is exercised there too. After the peer closes, a second `recv()` must fail immediately rather than hang to the timeout, which is what proves `connection_lost` still fails pending receives. The TLS cases mint a self-signed cert into a pytest temp dir.
+
+## [0.7.3] - 2026-07-24
+
+### Performance
+
+- **Sync receive without the intermediate copy (#29)**: tungstenite's owned `Bytes` payload now moves through the synchronous receive path instead of being copied into an intermediate `Vec<u8>`. Measured medians on an idle host: plain 1 MiB +9.1%, TLS 1 MiB +27.9%.
+
+- **Sync send borrows exact `bytes` (#30)**: exact CPython `bytes` payloads are sent through an owner-backed `Bytes` with no extraction copy; `bytearray`, `memoryview`, other buffer-protocol objects, and `bytes` subclasses keep the existing copy path. Pooled 7-round median: plain 1 MiB +7.2%.
+
+- **Interned Future-delivery identifiers (#31)**: `done` / `set_result` lookups in the hot async receive path use interned strings. Merged under the documented micro-optimization exception — the +2% performance gate was **not** met (~+1% on TLS 256 B, 7/7 positive rounds); this entry must not be cited as a perf-gate pass.
+
+### Fixed
+
+- **Interrupted socket I/O in the sync client (#34)**: blocking read/write/flush now follow PEP 475 — on `EINTR` the client checks pending Python signals first (so Ctrl-C still raises `KeyboardInterrupt`) and then retries, and an overall receive deadline is enforced across retries so `receive_timeout` is never extended by signal storms. Previously any signal delivered during a blocking `recv()` surfaced `RuntimeError: Interrupted system call`.
+
+### Internal
+
+- **Owner invariants compiler-enforced (#32)**: the sync-send `PyBytes` owner moved into a private module with a single constructor, making its safety invariants unconstructible-wrong; mutate-after-send tripwire tests added for mutable input types.
+
+- **Peer-close unified behind one seam (#33)**: close parsing and effects flow through `parse_close_payload` + `begin_peer_close` / `apply_peer_close` on every path (slow-path event sink, all three fast-path adapters, `connection_lost`, client `close()`). The remaining future-failure and transport calls made under an active `RefCell` borrow were eliminated — the same reentrancy discipline the 0.7.2 event sink introduced — and `handle_close_frame` / `fail_all_pending` were deleted outright.
+
 ## [0.7.2] - 2026-07-24
 
 ### Fixed

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

@@ -1519,7 +1519,7 @@ dependencies = [
 
 [[package]]
 name = "websocket_rs"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "base64 0.22.1",
  "bytes",

{websocket_rs-0.7.2 → websocket_rs-0.7.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "websocket_rs"
-version = "0.7.2"
+version = "0.7.4"
 edition = "2021"
 authors = ["coseto6125 <enorenor@gmail.com>"]
 description = "High-performance WebSocket client library for Python using Rust"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: websocket-rs
-Version: 0.7.2
+Version: 0.7.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

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

@@ -15,7 +15,7 @@ Fastest Python WebSocket client on plain TCP — wins **12/12** benchmark cells
 | Plain Python script / CLI tool (no asyncio) | **ws-rs sync** | picows is async-only; 1.3–7× over websocket-client (size-dependent) |
 | asyncio app, sequential RR ≤ 8 KB | **ws-rs sync** via `to_thread` | +13–28% over picows; sync bypasses asyncio overhead |
 | asyncio app, pipelined / streaming | **ws-rs async** | mean RPS +14–21% over picows on best path |
-| asyncio app, ≥ 1 MB payloads | **ws-rs async** ≈ **picows** | tied within 5%; server-side ceiling |
+| asyncio app, ≥ 1 MB payloads | **ws-rs async** | +15–20% over picows (RR, two servers, 7-round median; v0.7.3 zero-copy recv) |
 | RR latency-sensitive, payload ≥ 16 KB | **picows** | 3–5 µs lower per-message RTT (Cython cdef vs PyO3) |
 | Cross-network (real server, real RTT) | **Either** | network RT dominates; library choice < 1% of total latency |
 
@@ -34,10 +34,26 @@ Neutral Rust echo server (tokio-tungstenite), pinned cores, uvloop, 1 s discarde
 | 256 B | **15.0k** | 12.8k | 13.5k | 12.0k | 9.9k | 11.7k |
 | 8 KB  | **15.1k** | 13.4k | 13.2k | 11.8k | 9.6k | 10.1k |
 | 100 KB | **10.8k** | 10.3k | 10.5k | 9.4k | 8.1k | 4.5k |
-| 1 MB  | 4.0k | **4.2k** | **4.2k** | 3.4k | 3.0k | 509 |
+| 1 MB  | 4.0k | **4.2k** | 3.4k | 3.4k | 3.0k | 509 |
+
+> The legacy multi-client table above predates picows 2.1.1 and the v0.7.3 zero-copy path; the async-vs-picows section below supersedes its `ws-rs async` / `picows` columns. Its 1 MB `picows` cell is corrected here (was tied at 4.2k, now 3.4k on picows 2.1.1); the aiohttp / websockets / websocket-client columns are the older single-round figures pending a decision-grade re-measure.
 
 ws-rs wins or ties **12/12 cells** across three server architectures (tokio-tungstenite, fastwebsockets, picows-server).
 
+#### Apples-to-apples: async vs picows (v0.7.3, decision-grade)
+
+Both are `asyncio.Protocol` peers, so this is the fair head-to-head. Measured against **picows 2.1.1** (latest) on an AMD Ryzen 9 9950X / WSL2, single-connection plain-TCP RR loopback, one discarded warm-up round + **7 interleaved scored rounds**, pooled median. Cross-checked on two independent servers so the result isn't tied to one server implementation:
+
+| Payload | tokio-tungstenite server | picows-exact-echo server | verdict |
+|---------|---:|---:|---|
+| 256 B | 100.4% | ~parity | tie |
+| 8 KB | 102.5% | 102.4% | +2.4% |
+| 100 KB | 102.6% | 100.7% | ~parity–small win |
+| 1 MB | **120.0%** | **115.5%** | **+15–20%** |
+| **geomean** | **+6.1%** | **+5.2%** | ws-rs ahead |
+
+The 1 MB win is the direct payoff of the v0.7.3 zero-copy receive path. Scope: these numbers are specific to this machine and a request-response workload — they do **not** cover TLS, pipelining, multiple concurrent connections, or streaming throughput.
+
 ### Request-Response Throughput — TLS / wss:// (rustls)
 
 | Payload | **ws-rs sync** | ws-rs async | picows | aiohttp | websockets | websocket-client |
@@ -55,12 +71,11 @@ Sync wins TLS 256 B–100 KB by 30–60%. At 1 MB picows leads by ~7%; ws-rs tie
 
 📊 **[Full benchmarks — all 3 servers, TCP & TLS, latency distributions, compression](docs/BENCHMARKS.md)** | 📝 **[Optimization Research](docs/OPTIMIZATION_RESEARCH.md)**
 
-## ✨ What's New in v0.7.2
+## ✨ What's New in v0.7.3
 
-- **Timeout correctness**: async `connect()` now honors its `connect_timeout` / `receive_timeout` kwargs (previously dropped); native `connect_timeout=None` applies the 10 s default across all clients instead of hanging indefinitely. `receive_timeout=None` stays unlimited by design.
-- **Stability**: receiving a Ping on the buffered slow path under transport backpressure no longer panics — protocol decisions and transport effects are fully decoupled.
-- **SOCKS5**: proxy handshake replies split across TCP segments no longer fail the connection.
-- **Internals**: the buffered state machine is now a pure sans-I/O `ProtocolCore` with an allocation-free event sink, and the three fast-path frame walks share one monomorphized scanner — receive-path performance held or improved (several parity cells +3–11%).
+- **Faster sync client**: both directions of the synchronous client drop their per-message payload copy — large-message throughput up 7–28% (plain 1 MiB recv +9.1%, TLS 1 MiB recv +27.9%, plain 1 MiB send +7.2%; medians on an idle host).
+- **Signal-safe sync I/O**: blocking read/write now follow PEP 475 — signals during a blocking `recv()` no longer surface `Interrupted system call` errors, Ctrl-C still raises `KeyboardInterrupt`, and `receive_timeout` deadlines hold across retries.
+- **Internals**: peer-close handling unified behind one seam with all transport effects outside internal borrows; the sync-send buffer owner's safety invariants are now compiler-enforced.
 
 Full details in [CHANGELOG.md](CHANGELOG.md).
 

{websocket_rs-0.7.2 → websocket_rs-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "websocket-rs"
-version = "0.7.2"
+version = "0.7.4"
 description = "High-performance WebSocket client library for Python using Rust"
 readme = "README.pypi.md"
 authors = [

{websocket_rs-0.7.2 → websocket_rs-0.7.4}/src/native_client.rs

@@ -159,6 +159,13 @@ fn parse_header(buf: &[u8]) -> Option<(bool, bool, u8, usize, usize)> {
     Some((fin, rsv1, opcode, plen, hdr))
 }
 
+/// Close-frame payload → (code, reason). Empty/short payloads carry neither.
+fn parse_close_payload(payload: &[u8]) -> (Option<u16>, Option<String>) {
+    let code = (payload.len() >= 2).then(|| u16::from_be_bytes([payload[0], payload[1]]));
+    let reason = (payload.len() > 2).then(|| String::from_utf8_lossy(&payload[2..]).into_owned());
+    (code, reason)
+}
+
 struct FastFrame<'a> {
     opcode: u8,
     payload: &'a [u8],
@@ -350,10 +357,7 @@ impl ProtocolCore<'_> {
                 OP_CLOSE => {
                     self.buf.advance(hdr);
                     let payload = self.buf.split_to(plen);
-                    let code =
-                        (payload.len() >= 2).then(|| u16::from_be_bytes([payload[0], payload[1]]));
-                    let reason = (payload.len() > 2)
-                        .then(|| String::from_utf8_lossy(&payload[2..]).into_owned());
+                    let (code, reason) = parse_close_payload(&payload);
                     return Ok(Some(ProtocolEvent::Close { code, reason }));
                 }
                 OP_PING => {
@@ -1025,11 +1029,28 @@ impl NativeClient {
         Ok(())
     }
 
+    /// The peer half-closed (TCP FIN, or TLS close_notify). No further frame can
+    /// arrive, so let the transport close itself and let `connection_lost` do the
+    /// cleanup: returning true would mean "the protocol keeps this open", which is
+    /// wrong for a WebSocket client and is ignored under TLS anyway.
+    ///
+    /// asyncio.Protocol supplies a default, but this class is a pyclass and is not
+    /// a subclass of it, so the method has to exist here. Both call sites are
+    /// unconditional and unguarded (`sslproto._call_eof_received`,
+    /// `_SelectorSocketTransport._read_ready__data_received`), and the TLS one
+    /// routes a missing attribute into `_fatal_error`.
+    fn eof_received(&self) -> bool {
+        false
+    }
+
     fn connection_lost(&self, py: Python<'_>, _exc: Py<PyAny>) {
-        let mut state = self.state.borrow_mut();
-        state.closed = true;
-        Self::fail_all_pending(py, &mut state, "Connection lost");
-        state.transport = None;
+        let pending = {
+            let mut state = self.state.borrow_mut();
+            state.closed = true;
+            state.transport = None;
+            std::mem::take(&mut state.pending_recv)
+        };
+        Self::fail_pending(py, pending, "Connection lost");
     }
 
     // ---- User-facing API ----
@@ -1347,8 +1368,9 @@ impl NativeClient {
         state.create_future = None;
         state.wait_for = None;
         let write_queue = std::mem::take(&mut state.write_queue);
-        Self::fail_all_pending(py, &mut state, "Connection closed by client");
+        let pending = std::mem::take(&mut state.pending_recv);
         drop(state);
+        Self::fail_pending(py, pending, "Connection closed by client");
         // All mutex-guarded references are gone; drop pending writes and then
         // issue the close frame + transport.close() on the surviving transport ref.
         drop(write_queue);
@@ -1388,6 +1410,7 @@ impl NativeClient {
             self.data_received_inner(py, data)?;
             return Ok((data.len(), None));
         }
+        let mut close_effects = None;
         let outcome = walk_frames(data, |frame| -> PyResult<VisitOutcome> {
             match frame.opcode {
                 OP_TEXT | OP_BINARY => {
@@ -1397,14 +1420,18 @@ impl NativeClient {
                     Self::deliver_message(py, &mut state, msg)?;
                 }
                 OP_CLOSE => {
+                    let (code, reason) = parse_close_payload(frame.payload);
                     let mut state = self.state.borrow_mut();
-                    Self::handle_close_frame(py, &mut state, frame.payload);
+                    close_effects = Some(Self::begin_peer_close(py, &mut state, code, reason));
                     return Ok(VisitOutcome::Stop);
                 }
                 _ => {}
             }
             Ok(VisitOutcome::Continue)
         })?;
+        if let Some((pending, transport)) = close_effects {
+            Self::apply_peer_close(py, pending, transport);
+        }
         match outcome {
             ScanOutcome::Exhausted { consumed } | ScanOutcome::Stopped { consumed } => {
                 Ok((consumed, None))
@@ -1429,6 +1456,7 @@ impl NativeClient {
         };
         if can_fast_path {
             let mut state = self.state.borrow_mut();
+            let mut close_effects = None;
             let outcome = walk_frames(data, |frame| -> PyResult<VisitOutcome> {
                 match frame.opcode {
                     OP_TEXT | OP_BINARY => {
@@ -1447,7 +1475,8 @@ impl NativeClient {
                         Self::deliver_message(py, &mut state, msg)?;
                     }
                     OP_CLOSE => {
-                        Self::handle_close_frame(py, &mut state, frame.payload);
+                        let (code, reason) = parse_close_payload(frame.payload);
+                        close_effects = Some(Self::begin_peer_close(py, &mut state, code, reason));
                         return Ok(VisitOutcome::Stop);
                     }
                     _ => {}
@@ -1455,7 +1484,13 @@ impl NativeClient {
                 Ok(VisitOutcome::Continue)
             })?;
             let consumed = match outcome {
-                ScanOutcome::Stopped { .. } => return Ok(()),
+                ScanOutcome::Stopped { .. } => {
+                    drop(state);
+                    if let Some((pending, transport)) = close_effects {
+                        Self::apply_peer_close(py, pending, transport);
+                    }
+                    return Ok(());
+                }
                 ScanOutcome::Exhausted { consumed } if consumed == data.len() => return Ok(()),
                 ScanOutcome::Exhausted { consumed }
                 | ScanOutcome::Partial { consumed, .. }
@@ -1483,6 +1518,7 @@ impl NativeClient {
         };
         if can_fast_path {
             let mut state = self.state.borrow_mut();
+            let mut close_effects = None;
             let outcome = walk_frames(data, |frame| -> PyResult<VisitOutcome> {
                 match frame.opcode {
                     OP_TEXT | OP_BINARY => {
@@ -1491,7 +1527,8 @@ impl NativeClient {
                         Self::deliver_message(py, &mut state, msg)?;
                     }
                     OP_CLOSE => {
-                        Self::handle_close_frame(py, &mut state, frame.payload);
+                        let (code, reason) = parse_close_payload(frame.payload);
+                        close_effects = Some(Self::begin_peer_close(py, &mut state, code, reason));
                         return Ok(VisitOutcome::Stop);
                     }
                     _ => {}
@@ -1499,7 +1536,13 @@ impl NativeClient {
                 Ok(VisitOutcome::Continue)
             })?;
             let consumed = match outcome {
-                ScanOutcome::Stopped { .. } => return Ok(()),
+                ScanOutcome::Stopped { .. } => {
+                    drop(state);
+                    if let Some((pending, transport)) = close_effects {
+                        Self::apply_peer_close(py, pending, transport);
+                    }
+                    return Ok(());
+                }
                 ScanOutcome::Exhausted { consumed } if consumed == data.len() => return Ok(()),
                 ScanOutcome::Exhausted { consumed }
                 | ScanOutcome::Partial { consumed, .. }
@@ -1736,19 +1779,9 @@ impl NativeClient {
             ProtocolEvent::Close { code, reason } => {
                 let (pending, transport) = {
                     let mut state = self.state.borrow_mut();
-                    if code.is_some() {
-                        state.close_code = code;
-                        state.close_reason = reason;
-                    }
-                    state.closed = true;
-                    let pending = std::mem::take(&mut state.pending_recv);
-                    let transport = state.transport.as_ref().map(|t| t.clone_ref(py));
-                    (pending, transport)
+                    Self::begin_peer_close(py, &mut state, code, reason)
                 };
-                Self::fail_pending(py, pending, "Connection closed by peer");
-                if let Some(transport) = transport {
-                    let _ = transport.bind(py).call_method0("close");
-                }
+                Self::apply_peer_close(py, pending, transport);
                 Ok(EventFlow::Stop)
             }
             ProtocolEvent::ProtocolError(reason) => {
@@ -1799,8 +1832,12 @@ impl NativeClient {
         }
         if let Some(fut) = state.pending_recv.pop_front() {
             let fb = fut.bind(py);
-            if !fb.call_method0("done")?.extract::<bool>().unwrap_or(false) {
-                fb.call_method1("set_result", (msg,))?;
+            if !fb
+                .call_method0(pyo3::intern!(py, "done"))?
+                .extract::<bool>()
+                .unwrap_or(false)
+            {
+                fb.call_method1(pyo3::intern!(py, "set_result"), (msg,))?;
             }
         } else {
             state.backlog.push_back(msg);
@@ -1808,33 +1845,33 @@ impl NativeClient {
         Ok(())
     }
 
-    fn handle_close_frame(py: Python<'_>, state: &mut State, payload: &[u8]) {
-        if payload.len() >= 2 {
-            state.close_code = Some(u16::from_be_bytes([payload[0], payload[1]]));
-            state.close_reason =
-                (payload.len() > 2).then(|| String::from_utf8_lossy(&payload[2..]).into_owned());
+    /// Record a peer-initiated close in `state` and hand back the effects the
+    /// caller must apply AFTER releasing the State borrow — the same
+    /// reentrancy discipline as the slow-path event sink.
+    fn begin_peer_close(
+        py: Python<'_>,
+        state: &mut State,
+        code: Option<u16>,
+        reason: Option<String>,
+    ) -> (VecDeque<Py<PyAny>>, Option<Py<PyAny>>) {
+        if code.is_some() {
+            state.close_code = code;
+            state.close_reason = reason;
         }
         state.closed = true;
-        Self::fail_all_pending(py, state, "Connection closed by peer");
-        if let Some(t) = state.transport.as_ref() {
-            let tb = t.bind(py);
-            let _ = tb.call_method0("close");
-        }
-    }
-
-    fn fail_all_pending(py: Python<'_>, state: &mut State, msg: &str) {
-        while let Some(fut) = state.pending_recv.pop_front() {
-            let fb = fut.bind(py);
-            if !fb
-                .call_method0("done")
-                .and_then(|d| d.extract::<bool>())
-                .unwrap_or(true)
-            {
-                let _ = fb.call_method1(
-                    "set_exception",
-                    (PyConnectionError::new_err(msg.to_string()),),
-                );
-            }
+        let pending = std::mem::take(&mut state.pending_recv);
+        let transport = state.transport.as_ref().map(|t| t.clone_ref(py));
+        (pending, transport)
+    }
+
+    fn apply_peer_close(
+        py: Python<'_>,
+        pending: VecDeque<Py<PyAny>>,
+        transport: Option<Py<PyAny>>,
+    ) {
+        Self::fail_pending(py, pending, "Connection closed by peer");
+        if let Some(transport) = transport {
+            let _ = transport.bind(py).call_method0("close");
         }
     }
 }