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

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

@@ -5,6 +5,26 @@ 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.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.3}/Cargo.lock

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "websocket_rs"
-version = "0.7.2"
+version = "0.7.3"
 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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: websocket-rs
-Version: 0.7.2
+Version: 0.7.3
 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.3}/README.md

@@ -55,12 +55,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.3}/pyproject.toml

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

{websocket_rs-0.7.2 → websocket_rs-0.7.3}/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 => {
@@ -1026,10 +1030,13 @@ impl NativeClient {
     }
 
     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 +1354,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 +1396,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 +1406,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 +1442,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 +1461,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 +1470,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 +1504,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 +1513,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 +1522,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 +1765,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 +1818,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 +1831,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");
         }
     }
 }

{websocket_rs-0.7.2 → websocket_rs-0.7.3}/src/sync_client.rs

@@ -1,9 +1,10 @@
+use bytes::Bytes;
 use pyo3::exceptions::{PyConnectionError, PyRuntimeError, PyTimeoutError};
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyString};
-use std::io::{Read, Write};
+use std::io::{self, Read, Write};
 use std::net::{TcpStream, ToSocketAddrs};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use tungstenite::client::IntoClientRequest;
 use tungstenite::Message;
 use tungstenite::WebSocket;
@@ -52,48 +53,216 @@ pub(crate) fn build_rustls_client_config() -> PyResult<std::sync::Arc<rustls::Cl
 
 enum RecvResult {
     Text(String),
-    Binary(Vec<u8>),
+    Binary(Bytes),
 }
 
+mod send_pybytes_owner {
+    use super::*;
+
+    struct SendPyBytesOwner {
+        _bytes: Py<PyBytes>,
+        ptr: *const u8,
+        len: usize,
+    }
+
+    // SAFETY: this owner is constructed only from an exact CPython `bytes`, whose
+    // buffer is immutable and pointer-stable. `_bytes` is an owned reference cloned
+    // while the GIL is held before `py.detach`; it keeps the allocation alive until
+    // tungstenite drops the owner-backed `Bytes`. PyO3 permits `Py<PyBytes>` to cross
+    // threads and defers its decref until the GIL can be acquired.
+    unsafe impl Send for SendPyBytesOwner {}
+    unsafe impl Sync for SendPyBytesOwner {}
+
+    impl AsRef<[u8]> for SendPyBytesOwner {
+        fn as_ref(&self) -> &[u8] {
+            // SAFETY: `ptr` and `len` describe the immutable buffer owned by
+            // `_bytes`, which remains alive for this owner's entire lifetime.
+            unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
+        }
+    }
+
+    pub(super) fn new(bytes: &Bound<'_, PyBytes>) -> Bytes {
+        let data = bytes.as_bytes();
+        Bytes::from_owner(SendPyBytesOwner {
+            _bytes: bytes.clone().unbind(),
+            ptr: data.as_ptr(),
+            len: data.len(),
+        })
+    }
+}
+
+/// Keeps EINTR handling below rustls, whose internal I/O loop otherwise retries
+/// interrupted socket reads without giving Python a chance to raise a signal.
+struct SignalAwareTcpStream {
+    stream: TcpStream,
+    read_deadline: Option<Instant>,
+    enforce_read_deadline: bool,
+}
+
+impl SignalAwareTcpStream {
+    fn new(stream: TcpStream) -> Self {
+        Self {
+            stream,
+            read_deadline: None,
+            enforce_read_deadline: false,
+        }
+    }
+
+    fn apply_remaining_read_timeout(&self) -> io::Result<()> {
+        let remaining = self
+            .read_deadline
+            .and_then(|deadline| deadline.checked_duration_since(Instant::now()))
+            .filter(|remaining| !remaining.is_zero())
+            .ok_or_else(|| io::Error::new(io::ErrorKind::TimedOut, "read deadline elapsed"))?;
+        self.stream.set_read_timeout(Some(remaining))
+    }
+}
+
+impl Read for SignalAwareTcpStream {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        loop {
+            if self.enforce_read_deadline {
+                self.apply_remaining_read_timeout()?;
+            }
+            match self.stream.read(buf) {
+                Err(error) if error.kind() == io::ErrorKind::Interrupted => {
+                    check_python_signals()?;
+                    self.enforce_read_deadline = true;
+                }
+                result => return result,
+            }
+        }
+    }
+}
+
+impl Write for SignalAwareTcpStream {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        retry_interrupted(|| self.stream.write(buf))
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        retry_interrupted(|| self.stream.flush())
+    }
+}
+
+type TlsStream = rustls::StreamOwned<rustls::ClientConnection, SignalAwareTcpStream>;
+
 /// Type-erased stream for WebSocket (avoids generic type in pyclass)
 enum WsStream {
-    Plain(TcpStream),
-    Tls(Box<rustls::StreamOwned<rustls::ClientConnection, TcpStream>>),
+    Plain(SignalAwareTcpStream),
+    Tls(Box<TlsStream>),
 }
 
 impl Read for WsStream {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
-            WsStream::Plain(s) => s.read(buf),
-            WsStream::Tls(s) => s.read(buf),
+            Self::Plain(s) => s.read(buf),
+            Self::Tls(s) => s.read(buf),
         }
     }
 }
 
 impl Write for WsStream {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match self {
-            WsStream::Plain(s) => s.write(buf),
-            WsStream::Tls(s) => s.write(buf),
+            Self::Plain(s) => s.write(buf),
+            Self::Tls(s) => s.write(buf),
         }
     }
-    fn flush(&mut self) -> std::io::Result<()> {
+
+    fn flush(&mut self) -> io::Result<()> {
         match self {
-            WsStream::Plain(s) => s.flush(),
-            WsStream::Tls(s) => s.flush(),
+            Self::Plain(s) => s.flush(),
+            Self::Tls(s) => s.flush(),
         }
     }
 }
 
 impl WsStream {
+    fn plain(stream: TcpStream) -> Self {
+        Self::Plain(SignalAwareTcpStream::new(stream))
+    }
+
+    fn tls(connection: rustls::ClientConnection, stream: TcpStream) -> Self {
+        Self::Tls(Box::new(TlsStream::new(
+            connection,
+            SignalAwareTcpStream::new(stream),
+        )))
+    }
+
+    fn begin_read_deadline(&mut self, timeout: Duration) {
+        let socket = self.socket_mut();
+        socket.read_deadline = Some(Instant::now() + timeout);
+        socket.enforce_read_deadline = false;
+    }
+
+    fn clear_read_deadline(&mut self, timeout: Duration) {
+        let socket = self.socket_mut();
+        if socket.enforce_read_deadline {
+            let _ = socket.stream.set_read_timeout(Some(timeout));
+        }
+        socket.read_deadline = None;
+        socket.enforce_read_deadline = false;
+    }
+
     fn tcp_ref(&self) -> &TcpStream {
         match self {
-            WsStream::Plain(s) => s,
-            WsStream::Tls(s) => s.get_ref(),
+            Self::Plain(s) => &s.stream,
+            Self::Tls(s) => &s.get_ref().stream,
+        }
+    }
+
+    fn socket_mut(&mut self) -> &mut SignalAwareTcpStream {
+        match self {
+            Self::Plain(s) => s,
+            Self::Tls(s) => s.get_mut(),
+        }
+    }
+}
+
+fn check_python_signals() -> io::Result<()> {
+    // PEP 475 retries EINTR only after giving Python a chance to raise a
+    // pending signal exception such as KeyboardInterrupt.
+    Python::attach(|py| py.check_signals()).map_err(io::Error::from)
+}
+
+fn retry_interrupted<T>(mut operation: impl FnMut() -> io::Result<T>) -> io::Result<T> {
+    loop {
+        match operation() {
+            Err(error) if error.kind() == io::ErrorKind::Interrupted => check_python_signals()?,
+            result => return result,
         }
     }
 }
 
+fn is_python_error(error: &io::Error) -> bool {
+    // PyO3 preserves a PyErr wrapped in io::Error, allowing the API boundary
+    // to recover the original Python exception instead of replacing its type.
+    error.get_ref().is_some_and(|inner| inner.is::<PyErr>())
+}
+
+fn map_websocket_error(context: &str, error: tungstenite::Error) -> PyErr {
+    match error {
+        tungstenite::Error::Io(error) if is_python_error(&error) => error.into(),
+        error => PyRuntimeError::new_err(format!("{context} failed: {error}")),
+    }
+}
+
+fn map_receive_error(error: tungstenite::Error, receive_timeout: f64) -> PyErr {
+    match error {
+        tungstenite::Error::Io(error) if is_python_error(&error) => error.into(),
+        tungstenite::Error::Io(error)
+            if matches!(
+                error.kind(),
+                io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock
+            ) =>
+        {
+            PyTimeoutError::new_err(format!("Receive timed out ({receive_timeout} seconds)"))
+        }
+        error => PyRuntimeError::new_err(format!("Receive failed: {error}")),
+    }
+}
+
 /// Sync client connection (pure sync, no async runtime overhead)
 #[pyclass(name = "ClientConnection", module = "websocket_rs.sync.client")]
 pub struct SyncClientConnection {
@@ -192,14 +361,18 @@ impl SyncClientConnection {
                     })?;
                 let conn = rustls::ClientConnection::new(config, server_name)
                     .map_err(|e| PyConnectionError::new_err(format!("TLS init failed: {}", e)))?;
-                let tls = rustls::StreamOwned::new(conn, tcp);
-                WsStream::Tls(Box::new(tls))
+                WsStream::tls(conn, tcp)
             } else {
-                WsStream::Plain(tcp)
+                WsStream::plain(tcp)
             };
 
-            let (ws, _) = tungstenite::client(request, ws_stream).map_err(|e| {
-                PyConnectionError::new_err(format!("WebSocket handshake failed: {}", e))
+            let (ws, _) = tungstenite::client(request, ws_stream).map_err(|error| match error {
+                tungstenite::HandshakeError::Failure(tungstenite::Error::Io(error))
+                    if is_python_error(&error) =>
+                {
+                    error.into()
+                }
+                error => PyConnectionError::new_err(format!("WebSocket handshake failed: {error}")),
             })?;
 
             // Reset timeouts: read = receive_timeout, write = unlimited
@@ -224,6 +397,8 @@ impl SyncClientConnection {
     fn send<'py>(&mut self, py: Python<'py>, message: &Bound<'py, PyAny>) -> PyResult<()> {
         let msg = if let Ok(s) = message.cast::<PyString>() {
             Message::Text(s.to_str()?.into())
+        } else if let Ok(bytes) = message.cast_exact::<PyBytes>() {
+            Message::Binary(send_pybytes_owner::new(bytes))
         } else if let Ok(bytes) = message.extract::<Vec<u8>>() {
             Message::Binary(bytes.into())
         } else {
@@ -237,52 +412,54 @@ impl SyncClientConnection {
                 .ok_or_else(|| PyRuntimeError::new_err("WebSocket is not connected"))?;
 
             ws.send(msg)
-                .map_err(|e| PyRuntimeError::new_err(format!("Send failed: {}", e)))
+                .map_err(|error| map_websocket_error("Send", error))
         })
     }
 
     fn recv(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let receive_timeout = self.receive_timeout;
         let result = py.detach(|| {
             let ws = self
                 .ws
                 .as_mut()
                 .ok_or_else(|| PyRuntimeError::new_err("WebSocket is not connected"))?;
 
-            loop {
-                let msg = ws.read().map_err(|e| match &e {
-                    tungstenite::Error::Io(io_err)
-                        if matches!(
-                            io_err.kind(),
-                            std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock
-                        ) =>
-                    {
-                        PyTimeoutError::new_err(format!(
-                            "Receive timed out ({} seconds)",
-                            self.receive_timeout
-                        ))
-                    }
-                    _ => PyRuntimeError::new_err(format!("Receive failed: {}", e)),
-                })?;
+            ws.get_mut()
+                .begin_read_deadline(Duration::from_secs_f64(receive_timeout));
+            let mut close_details = None;
+            let result = loop {
+                let msg = match ws.read() {
+                    Ok(msg) => msg,
+                    Err(error) => break Err(map_receive_error(error, receive_timeout)),
+                };
 
                 match msg {
-                    Message::Text(text) => return Ok(RecvResult::Text(text.to_string())),
-                    Message::Binary(data) => return Ok(RecvResult::Binary(data.to_vec())),
+                    Message::Text(text) => break Ok(RecvResult::Text(text.to_string())),
+                    Message::Binary(data) => break Ok(RecvResult::Binary(data)),
                     Message::Ping(_) | Message::Pong(_) => continue,
                     Message::Close(frame) => {
                         if let Some(f) = frame {
-                            self.close_code = Some(f.code.into());
-                            self.close_reason = Some(f.reason.to_string());
+                            close_details = Some((f.code.into(), f.reason.to_string()));
                         }
-                        return Err(PyRuntimeError::new_err("Connection closed by server"));
+                        break Err(PyRuntimeError::new_err("Connection closed by server"));
+                    }
+                    _ => {
+                        break Err(PyRuntimeError::new_err("Received unsupported message type"));
                     }
-                    _ => return Err(PyRuntimeError::new_err("Received unsupported message type")),
                 }
+            };
+            ws.get_mut()
+                .clear_read_deadline(Duration::from_secs_f64(receive_timeout));
+            if let Some((code, reason)) = close_details {
+                self.close_code = Some(code);
+                self.close_reason = Some(reason);
             }
+            result
         })?;
 
         match result {
             RecvResult::Text(s) => Ok(PyString::new(py, &s).into_any().unbind()),
-            RecvResult::Binary(b) => Ok(PyBytes::new(py, &b).into_any().unbind()),
+            RecvResult::Binary(b) => Ok(PyBytes::new(py, b.as_ref()).into_any().unbind()),
         }
     }
 
@@ -291,18 +468,30 @@ impl SyncClientConnection {
         py.detach(|| {
             if let Some(mut ws) = self.ws.take() {
                 // Set a timeout for the close handshake
-                let tcp_ref = ws.get_ref().tcp_ref();
-                let _ = tcp_ref.set_read_timeout(Some(Duration::from_secs_f64(close_timeout)));
-                if let Err(e) = ws.close(None) {
-                    // Read remaining frames until close confirmation or timeout
-                    if !matches!(e, tungstenite::Error::ConnectionClosed) {
+                let close_duration = Duration::from_secs_f64(close_timeout);
+                let _ = ws
+                    .get_ref()
+                    .tcp_ref()
+                    .set_read_timeout(Some(close_duration));
+                ws.get_mut().begin_read_deadline(close_duration);
+                match ws.close(None) {
+                    Err(tungstenite::Error::Io(error)) if is_python_error(&error) => {
+                        return Err(error.into());
+                    }
+                    Err(error) if !matches!(error, tungstenite::Error::ConnectionClosed) => {
+                        // Read remaining frames until close confirmation or timeout
                         loop {
                             match ws.read() {
-                                Ok(Message::Close(_)) | Err(_) => break,
+                                Ok(Message::Close(_)) => break,
+                                Err(tungstenite::Error::Io(error)) if is_python_error(&error) => {
+                                    return Err(error.into());
+                                }
+                                Err(_) => break,
                                 _ => continue,
                             }
                         }
                     }
+                    _ => {}
                 }
             }
             Ok(())
@@ -317,7 +506,7 @@ impl SyncClientConnection {
                 .as_mut()
                 .ok_or_else(|| PyRuntimeError::new_err("WebSocket is not connected"))?;
             ws.send(Message::Ping(data.into()))
-                .map_err(|e| PyRuntimeError::new_err(format!("Ping failed: {}", e)))
+                .map_err(|error| map_websocket_error("Ping", error))
         })
     }
 
@@ -329,7 +518,7 @@ impl SyncClientConnection {
                 .as_mut()
                 .ok_or_else(|| PyRuntimeError::new_err("WebSocket is not connected"))?;
             ws.send(Message::Pong(data.into()))
-                .map_err(|e| PyRuntimeError::new_err(format!("Pong failed: {}", e)))
+                .map_err(|error| map_websocket_error("Pong", error))
         })
     }
 

{websocket_rs-0.7.2 → websocket_rs-0.7.3}/tests/test_compatibility.py

@@ -7,6 +7,7 @@ import asyncio
 import sys
 import threading
 import time
+from array import array
 
 import pytest
 import websockets
@@ -21,6 +22,10 @@ sync_connect = websocket_rs.sync.client.connect
 async_connect = websocket_rs.async_client.connect
 
 
+class BytesSubclass(bytes):
+    pass
+
+
 async def start_echo_server():
     async def echo(websocket):
         async for message in websocket:
@@ -109,6 +114,71 @@ def test_rust_sync_api():
     print("\n所有同步 API 測試通過！\n")
 
 
+def test_sync_recv_binary_move_path_preserves_content():
+    payload = bytes(range(256)) * 4096
+
+    with sync_connect("ws://localhost:8765") as ws:
+        ws.send(payload)
+        received = ws.recv()
+
+    assert isinstance(received, bytes)
+    assert received == payload
+
+
+@pytest.mark.parametrize(
+    ("payload", "mutate_after_send"),
+    [
+        pytest.param(bytearray(b"bytearray payload"), True, id="bytearray"),
+        pytest.param(memoryview(b"memoryview payload"), False, id="memoryview"),
+        pytest.param(array("B", b"buffer object payload"), True, id="buffer-object"),
+        pytest.param(BytesSubclass(b"bytes subclass payload"), False, id="bytes-subclass"),
+    ],
+)
+def test_sync_send_non_exact_bytes_copy_path_round_trips(payload, mutate_after_send):
+    expected = bytes(payload)
+
+    with sync_connect("ws://localhost:8765") as ws:
+        ws.send(payload)
+        if mutate_after_send:
+            # Tripwire for future deferred-write or borrow-path expansion, not
+            # a probe of the current synchronous send behavior.
+            for index in range(len(payload)):
+                payload[index] ^= 0xFF
+            assert bytes(payload) != expected
+        received = ws.recv()
+
+    assert received == expected
+
+
+def test_sync_send_exact_bytes_owner_survives_allocator_pressure():
+    stop = threading.Event()
+    churn_cycles = 0
+
+    def churn_allocator():
+        nonlocal churn_cycles
+        while not stop.is_set():
+            blocks = [bytes(bytearray(64 * 1024)) for _ in range(8)]
+            churn_cycles += 1
+            del blocks
+
+    churn_thread = threading.Thread(target=churn_allocator, daemon=True)
+    churn_thread.start()
+    try:
+        with sync_connect("ws://localhost:8765") as ws:
+            for marker in range(16):
+                expected = bytes([marker]) * (256 * 1024)
+                payload = bytes(bytearray(expected))
+                assert type(payload) is bytes
+                ws.send(payload)
+                del payload
+                assert ws.recv() == expected
+    finally:
+        stop.set()
+        churn_thread.join(timeout=2)
+
+    assert churn_cycles > 0
+
+
 async def test_python_async_api():
     """測試 Python 原生 async API"""
     print("測試 Python websockets 異步 API...")

{websocket_rs-0.7.2 → websocket_rs-0.7.3}/tests/test_timeout_and_errors.py

@@ -8,6 +8,8 @@ Covers issues found in code review:
 """
 
 import asyncio
+import os
+import signal
 import socket
 import sys
 import threading
@@ -25,6 +27,10 @@ sys.stdout.reconfigure(encoding="utf-8")
 async def start_echo_server(port=8766):
     async def echo(ws):
         async for msg in ws:
+            if msg == b"delayed EINTR reply":
+                await asyncio.sleep(0.25)
+            elif msg == b"delayed EINTR timeout":
+                await asyncio.sleep(1)
             await ws.send(msg)
 
     return await websockets.serve(echo, "localhost", port, ping_interval=None)
@@ -137,6 +143,96 @@ def test_sync_recv_timeout():
             print(f"✓ sync recv timeout works ({elapsed:.1f}s)")
 
 
+@pytest.mark.skipif(not hasattr(signal, "SIGUSR1"), reason="SIGUSR1 is unavailable")
+def test_sync_recv_retries_eintr_after_python_signal():
+    previous_handler = signal.signal(signal.SIGUSR1, lambda *_: None)
+    stop = threading.Event()
+    signals_sent = 0
+
+    def send_signals():
+        nonlocal signals_sent
+        while not stop.wait(0.01):
+            os.kill(os.getpid(), signal.SIGUSR1)
+            signals_sent += 1
+
+    try:
+        with websocket_rs.sync.client.ClientConnection(
+            "ws://localhost:8766", receive_timeout=1.0
+        ) as ws:
+            ws.send(b"delayed EINTR reply")
+            signal_thread = threading.Thread(target=send_signals, daemon=True)
+            signal_thread.start()
+            try:
+                received = ws.recv()
+            finally:
+                stop.set()
+                signal_thread.join(timeout=1)
+    finally:
+        signal.signal(signal.SIGUSR1, previous_handler)
+
+    assert signals_sent > 0
+    assert received == b"delayed EINTR reply"
+
+
+@pytest.mark.skipif(not hasattr(signal, "SIGUSR1"), reason="SIGUSR1 is unavailable")
+def test_sync_recv_eintr_retries_preserve_timeout_deadline():
+    previous_handler = signal.signal(signal.SIGUSR1, lambda *_: None)
+    stop = threading.Event()
+    signals_sent = 0
+
+    def send_signals():
+        nonlocal signals_sent
+        while not stop.wait(0.01):
+            os.kill(os.getpid(), signal.SIGUSR1)
+            signals_sent += 1
+
+    try:
+        with websocket_rs.sync.client.ClientConnection(
+            "ws://localhost:8766", receive_timeout=0.2
+        ) as ws:
+            ws.send(b"delayed EINTR timeout")
+            signal_thread = threading.Thread(target=send_signals, daemon=True)
+            signal_thread.start()
+            started = time.perf_counter()
+            try:
+                with pytest.raises(TimeoutError):
+                    ws.recv()
+            finally:
+                elapsed = time.perf_counter() - started
+                stop.set()
+                signal_thread.join(timeout=1)
+    finally:
+        signal.signal(signal.SIGUSR1, previous_handler)
+
+    assert signals_sent > 0
+    assert 0.1 < elapsed < 0.6
+
+
+@pytest.mark.skipif(
+    os.name != "posix" or not hasattr(signal, "SIGINT"),
+    reason="POSIX SIGINT is unavailable",
+)
+def test_sync_recv_eintr_propagates_keyboard_interrupt():
+    previous_handler = signal.signal(signal.SIGINT, signal.default_int_handler)
+
+    def interrupt_recv():
+        time.sleep(0.05)
+        os.kill(os.getpid(), signal.SIGINT)
+
+    try:
+        with websocket_rs.sync.client.ClientConnection(
+            "ws://localhost:8766", receive_timeout=1.0
+        ) as ws:
+            ws.send(b"delayed EINTR reply")
+            signal_thread = threading.Thread(target=interrupt_recv, daemon=True)
+            signal_thread.start()
+            with pytest.raises(KeyboardInterrupt):
+                ws.recv()
+            signal_thread.join(timeout=1)
+    finally:
+        signal.signal(signal.SIGINT, previous_handler)
+
+
 async def test_async_send_after_close():
     """Async: sending after close should raise RuntimeError."""
     ws = await websocket_rs.async_client.connect("ws://localhost:8766")
@@ -209,27 +305,5 @@ async def test_async_connect_function_receive_timeout_kwarg_expires_promptly():
         await ws.close()
 
 
-async def main():
-    server = await start_echo_server(8766)
-
-    try:
-        print("=== Timeout & Error Tests ===\n")
-
-        # Sync tests
-        test_sync_connect_timeout()
-        test_sync_connect_forwards_params()
-        await asyncio.to_thread(test_sync_send_after_close)
-        await asyncio.to_thread(test_sync_recv_timeout)
-
-        # Async tests
-        await test_async_send_after_close()
-        await test_async_recv_timeout()
-        await test_async_connect_timeout()
-
-        print("\n✅ All timeout & error tests passed!")
-    finally:
-        server.close()
-
-
 if __name__ == "__main__":
-    asyncio.run(main())
+    raise SystemExit(pytest.main([__file__]))