httpunk 0.2.1__tar.gz → 0.2.2__tar.gz

{httpunk-0.2.1 → httpunk-0.2.2}/Cargo.lock

@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "bytes",
  "h2",

{httpunk-0.2.1 → httpunk-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.2.1"
+version = "0.2.2"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",

{httpunk-0.2.1 → httpunk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/_backend/asyncio.py

@@ -20,6 +20,8 @@ import errno as _errno
 import ssl as _ssl
 import time as _time
 
+from ..exceptions import fresh_exc as _fresh_exc
+
 
 _READ_HIGH_WATER = 2**16  # 64 KiB — pause reading past this (matches StreamReader's default limit)
 
@@ -65,7 +67,12 @@ class _AsyncioStream(asyncio.Protocol):
         return True
 
     def connection_lost(self, exc):
-        self._error = exc
+        # Store the error PRISTINE (no traceback) and only ever raise copies of
+        # it (below): this object outlives the failure, and a stored exception
+        # instance re-raised through the caller's stack would accumulate those
+        # frames onto its `__traceback__` — a refcount-invisible cycle pinning
+        # everything the frames reference until a gen-2 GC (exceptions.fresh_exc).
+        self._error = exc.with_traceback(None) if exc is not None else None
         self._eof = True
         self._conn_lost = True  # writes to a dead socket must now raise (F32)
         self._wake_reader()
@@ -74,7 +81,7 @@ class _AsyncioStream(asyncio.Protocol):
             if exc is None:
                 self._drain_waiter.set_result(None)
             else:
-                self._drain_waiter.set_exception(exc)
+                self._drain_waiter.set_exception(_fresh_exc(exc))
 
     def pause_writing(self):
         self._writing_paused = True
@@ -94,7 +101,9 @@ class _AsyncioStream(asyncio.Protocol):
             return self._take(max_bytes)
         if self._eof:
             if self._error is not None:
-                raise self._error
+                # A fresh copy per raise — never the stored instance (see
+                # connection_lost / exceptions.fresh_exc).
+                raise _fresh_exc(self._error) from self._error
             return b""
         if self._read_waiter is not None:
             # Single-reader contract: a second concurrent receive_some would overwrite
@@ -110,7 +119,7 @@ class _AsyncioStream(asyncio.Protocol):
         if self._buffer:
             return self._take(max_bytes)
         if self._error is not None:
-            raise self._error
+            raise _fresh_exc(self._error) from self._error
         return b""
 
     async def send_all(self, data):
@@ -119,7 +128,9 @@ class _AsyncioStream(asyncio.Protocol):
         # EPIPE/ECONNRESET — drivers detect a dead peer via that failure. Surface the
         # real error, or EPIPE if the close carried none (a clean peer FIN).
         if self._conn_lost:
-            raise self._error or BrokenPipeError(_errno.EPIPE, "connection lost")
+            if self._error is not None:
+                raise _fresh_exc(self._error) from self._error
+            raise BrokenPipeError(_errno.EPIPE, "connection lost")
         self._transport.write(data)
         if self._writing_paused:  # transport buffer over high-water — wait for resume (drain)
             if self._drain_waiter is None:

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/exceptions.py

@@ -30,6 +30,8 @@ may have begun.
 
 from __future__ import annotations
 
+import copy as _copy
+
 from ._httpunk import (
     ConnectionClosedError as ConnectionClosedError,
     H2Error as H2Error,
@@ -49,6 +51,34 @@ def _reason(code):
         return code  # unknown/experimental error code — keep the raw int
 
 
+def fresh_exc(exc: BaseException) -> BaseException:
+    """A fresh, traceback-free copy of `exc`, for storing or re-raising a saved
+    connection/stream error.
+
+    Runtime-forced divergence from hyper: hyper shares a connection's fatal error
+    by cloning an `Arc<Error>`; a Python exception instance instead accumulates
+    every propagation's frames onto its `__traceback__`, and a traceback's frames
+    keep their locals alive — so a caught exception stored on a long-lived object
+    (conn, stream, backend transport) and re-raised as the same shared instance
+    pins the entire frame graph of every propagation in a reference cycle only
+    cyclic GC can free (observed as stalled-until-gen-2-GC connections downstream).
+    The rule throughout httpunk: **store copies, raise copies** — store
+    `fresh_exc(exc)` (or strip a consumed-once hand-off in place), and re-raise
+    stored errors as `raise fresh_exc(err) from err`, so no stored instance ever
+    carries frames.
+
+    Copies via `copy.copy`: `BaseException.__reduce__` rebuilds from type + args
+    and restores `__dict__` extras (e.g. `request_unsent`); `GoAwayError` /
+    `StreamResetError` define `__reduce__` because their args don't roundtrip
+    through their constructors. The copy carries no `__traceback__` / `__cause__` /
+    `__context__`. An uncopyable exception is returned as-is — degraded (shared
+    instance) but functional."""
+    try:
+        return _copy.copy(exc)
+    except Exception:
+        return exc
+
+
 class GoAwayError(H2Error):
     """The peer sent GOAWAY. Streams with id > `last_stream_id` were not
     processed and are safe to retry on a new connection."""
@@ -63,6 +93,11 @@ class GoAwayError(H2Error):
         self.debug_data = debug_data
         super().__init__(f"GOAWAY(last_stream_id={last_stream_id}, error_code={self.error_code!r})")
 
+    def __reduce__(self):
+        # `args` holds the formatted message, not the constructor params — rebuild
+        # from the real params so `copy.copy`/pickle (and `fresh_exc`) work.
+        return (type(self), (self.last_stream_id, int(self.error_code), self.debug_data), self.__dict__)
+
 
 class StreamResetError(H2Error):
     """The peer sent RST_STREAM for this stream."""
@@ -74,3 +109,7 @@ class StreamResetError(H2Error):
         self.stream_id = stream_id
         self.error_code = _reason(error_code)
         super().__init__(f"RST_STREAM(stream_id={stream_id}, error_code={self.error_code!r})")
+
+    def __reduce__(self):
+        # See GoAwayError.__reduce__.
+        return (type(self), (self.stream_id, int(self.error_code)), self.__dict__)

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h1/client.py

@@ -18,7 +18,7 @@ from typing import TYPE_CHECKING, Any
 
 from .._common import BaseClientConnection
 from .._httpunk import H1BodyDecoder, H1Codec
-from ..exceptions import ConnectionClosedError
+from ..exceptions import ConnectionClosedError, fresh_exc
 from ..http import HeaderMap
 from ..types import Response
 from .connection import H1ConnectionBase
@@ -226,7 +226,11 @@ class Connection(H1ConnectionBase):
             data = await transport.receive_some(65536)
         except Exception as exc:
             if self._exchange_active:
-                self._watcher_error = exc  # surfaced by _read_head's first read
+                # Consumed-once hand-off (nulled at the `_read_head` take, so raising
+                # the instance there is safe) — but strip the watcher frames now: while
+                # parked here it would otherwise pin this conn/transport in a cycle
+                # (exceptions.fresh_exc). Surfaced by _read_head's first read.
+                self._watcher_error = exc.with_traceback(None)
             elif not self._closed:
                 self._fail(exc)
             return
@@ -248,7 +252,7 @@ class Connection(H1ConnectionBase):
         await self._acquire()
         self._slot.release()
         if self.error is not None:
-            raise self.error
+            raise fresh_exc(self.error) from self.error  # a copy per raise (exceptions.fresh_exc)
         if self._closed:
             raise ConnectionClosedError("connection closed")
 
@@ -271,9 +275,11 @@ class Connection(H1ConnectionBase):
         if self._closed or self.error is not None:
             self._busy = False
             self._slot.release()
-            exc = self.error or ConnectionClosedError("connection closed")
+            # The flag rides the raised copy, not the stored error: it holds for
+            # THIS give-back, while a stored flag would leak onto unrelated raises.
+            exc = fresh_exc(self.error) if self.error is not None else ConnectionClosedError("connection closed")
             exc.request_unsent = True
-            raise exc
+            raise exc from self.error
         # `require_empty_read`'s buffered-bytes fast path at send time (conn.rs
         # L463-465; regression test client_read_bytes_before_writing_request):
         # a server may not send anything before the client's next request, and
@@ -291,8 +297,9 @@ class Connection(H1ConnectionBase):
             self.poison_unexpected(len(pending))  # records the error AND closes
             self._busy = False
             self._slot.release()
-            self.error.request_unsent = True
-            raise self.error
+            exc = fresh_exc(self.error)
+            exc.request_unsent = True
+            raise exc from self.error
         # The exchange starts NOW: the watcher is not stopped (its parked read
         # is never cancelled — see `_watch_idle`); this sync flag redirects its
         # completing read from the idle rules to the exchange, whose `_read_head`
@@ -438,7 +445,7 @@ class Connection(H1ConnectionBase):
             # for `_read_head`, so DEFER — record it and surface it only if no head
             # arrives (EOF). Do NOT signal `body_failed`, or we'd race away that buffered
             # response (F11).
-            write_error.append(exc)
+            write_error.append(exc.with_traceback(None))  # stored past this frame — strip (exceptions.fresh_exc)
         except Exception as exc:
             # A BODY-ITERABLE / framing error (the caller's body generator raised, or a
             # length mismatch): the request can't complete and no valid response is
@@ -447,7 +454,7 @@ class Connection(H1ConnectionBase):
             # on `receive_some` until the server times out (F12). The transport is closed
             # by `send_request`'s outer `_fail` once the writer is joined — closing it
             # here (inside the writer's scope) wedges that join.
-            write_error.append(exc)
+            write_error.append(exc.with_traceback(None))  # stored past this frame — strip (exceptions.fresh_exc)
             body_failed.set()
 
     async def _read_head(self, codec, write_error=None):
@@ -477,15 +484,19 @@ class Connection(H1ConnectionBase):
                 # dispatches are legitimate). Surface the recorded verdict —
                 # the unexpected-bytes poison (hyper `new_unexpected_message`)
                 # or the clean close — not a generic error that would mask it.
-                raise self.error or ConnectionClosedError("connection closed")
+                if self.error is not None:
+                    raise fresh_exc(self.error) from self.error
+                raise ConnectionClosedError("connection closed")
         while True:
             if data is None:
                 data = await self.transport.receive_some(65536)
             if not data:
                 # EOF before a full head. If the body write also failed (server
-                # closed both directions), surface that as the cause.
+                # closed both directions), surface that as the cause. A copy — the
+                # instance stays in `write_error`, whose frames would join the
+                # raise's traceback (exceptions.fresh_exc).
                 if write_error:
-                    raise write_error[0]
+                    raise fresh_exc(write_error[0]) from write_error[0]
                 raise ConnectionClosedError("connection closed before the response head")
             buffered += len(data)
             head = codec.receive_head(data)
@@ -509,7 +520,7 @@ class Connection(H1ConnectionBase):
         # NOT fire this (F11 — an early response may be buffered), so the normal path
         # always lets `_read_head` win the race.
         await body_failed.wait()
-        raise write_error[0]
+        raise fresh_exc(write_error[0]) from write_error[0]
 
     def poison_unexpected(self, nbytes):
         """The server sent `nbytes` unsolicited bytes outside a response — an
@@ -577,7 +588,10 @@ class Connection(H1ConnectionBase):
         # inside an exchange (slot held, watcher joined at send_request entry)
         # or from the watcher itself.
         if self.error is None and not isinstance(exc, ConnectionClosedError):
-            self.error = exc
+            # A stripped COPY: the caught instance keeps propagating to the caller
+            # and would accumulate every frame above onto a stored traceback
+            # (exceptions.fresh_exc).
+            self.error = fresh_exc(exc)
         self._closed = True
         self._close_transport()
 

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h2/client.py

@@ -23,7 +23,7 @@ from collections.abc import Awaitable
 from typing import TYPE_CHECKING, Any
 
 from .._common import BaseClientConnection
-from ..exceptions import ConnectionClosedError, H2ProtocolError, H2Reason
+from ..exceptions import ConnectionClosedError, H2ProtocolError, H2Reason, fresh_exc
 from ..types import Response
 from .connection import PREFACE, H2ConnectionBase
 from .settings import LocalSettings, Settings
@@ -119,12 +119,16 @@ class ClientStreamManager(StreamManager):
         # 9113 §8.2.2) — same early-validation rationale as the trailers check
         # in `send_request` (#925): a caller error, the connection stays usable.
         self.check_send_headers(headers)
+        # All the stored-error raises below raise a COPY per consumer — many streams
+        # surface the one stored `_conn.error`/`_goaway`, and a shared raised
+        # instance would accumulate every caller's frames (exceptions.fresh_exc).
         if self._goaway is not None:
-            raise self._goaway
+            raise fresh_exc(self._goaway) from self._goaway
         await self._acquire_stream_slot()  # blocks on the limit; increments the count
         if self._conn.error is not None or self._goaway is not None:
             self._release_count()
-            raise self._conn.error or self._goaway
+            src = self._conn.error or self._goaway
+            raise fresh_exc(src) from src
         async with self._new_stream_lock:
             stream_id = self._next_id
             if stream_id > _MAX_STREAM_ID:
@@ -152,8 +156,9 @@ class ClientStreamManager(StreamManager):
         # missed it. Re-check and abort our own stream (idempotent) so a caller
         # doesn't wait forever on a response head that will never arrive.
         if self._conn.error is not None or self._goaway is not None:
-            self._abort_stream(st, self._conn.error or self._goaway)
-            raise self._conn.error or self._goaway
+            src = self._conn.error or self._goaway
+            self._abort_stream(st, src)
+            raise fresh_exc(src) from src
         return st
 
     # ===== MAX_CONCURRENT_STREAMS (h2: proto/streams/counts.rs) =====
@@ -186,9 +191,9 @@ class ClientStreamManager(StreamManager):
             # to free a slot, which may never happen (F20). `_on_go_away`/`_on_fail`
             # set `_slot_evt` to wake us for this re-check.
             if self._goaway is not None:
-                raise self._goaway
+                raise fresh_exc(self._goaway) from self._goaway
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             await self._slot_evt.wait()
 
     def _release_count(self):
@@ -214,9 +219,9 @@ class ClientStreamManager(StreamManager):
             # existing conn_error (streams.rs L879). Also keeps this consistent with
             # `open_stream`, which checks `_goaway` first (F20).
             if self._goaway is not None:
-                raise self._goaway
+                raise fresh_exc(self._goaway) from self._goaway
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             # Non-reserving: just observe capacity (a racy read is fine — we don't
             # increment; a concurrent open re-applies the gate under the lock).
             if self._can_open():
@@ -310,7 +315,7 @@ class Connection(H2ConnectionBase):
         await self._begin(PREFACE, settings)
         await self._ready_evt.wait()
         if self.error is not None:
-            raise self.error
+            raise fresh_exc(self.error) from self.error  # a copy per raise (exceptions.fresh_exc)
 
     def _signal_ready(self):
         self._ready_evt.set()
@@ -439,7 +444,10 @@ class H2Connection(BaseClientConnection):
         # bug is a scheduling race where `send_request` re-checks only after the
         # connection has failed, which a quiet loopback never reproduces.)
         if stream.status is None:  # woken by a reset/failure, not a real response head
-            raise stream.error or self._conn.error or ConnectionClosedError("connection closed before response")
+            src = stream.error or self._conn.error
+            if src is not None:
+                raise fresh_exc(src) from src
+            raise ConnectionClosedError("connection closed before response")
         return Response(stream.status, stream.headers, H2ResponseBody(stream, self._conn.streams))
 
     def _resolve(self, target):

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h2/connection.py

@@ -34,7 +34,7 @@ from .._httpunk import (
     H2FrameWindowUpdate as WindowUpdate,
     H2StreamError,
 )
-from ..exceptions import ConnectionClosedError, GoAwayError, H2Error, H2Reason
+from ..exceptions import ConnectionClosedError, GoAwayError, H2Error, H2Reason, fresh_exc
 from .settings import Action
 from .streams import _StreamError
 
@@ -511,6 +511,12 @@ class H2ConnectionBase:
     def _fail(self, exc):
         # h2: proto/connection.rs `handle_poll2_result` (L430) -> the connection
         # error fans out to every stream via streams.rs `Streams::handle_error` (L362).
+        # Store/fan out a stripped COPY (h2 clones an Arc'd error the same way):
+        # some callers keep propagating the caught instance after this, which would
+        # accumulate their frames onto a stored traceback (exceptions.fresh_exc).
+        # Sharing the one copy across conn + streams is fine — raise sites raise
+        # copies of it, so its traceback never grows.
+        exc = fresh_exc(exc)
         self.error = exc
         self.streams.fail_all(exc)
         self._signal_ready()  # unblock connect() if the handshake never completed (client); no-op (server)

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h2/server.py

@@ -37,6 +37,7 @@ from ..exceptions import (
     ConnectionClosedError,
     H2ProtocolError,
     H2Reason,
+    fresh_exc,
 )
 from ..http import HeaderMap
 from .connection import PREFACE, H2ConnectionBase
@@ -105,7 +106,7 @@ class ServerRequest:
             await self._manager.release_capacity(self._stream, len(chunk))
             yield chunk
         if self._stream.error is not None:
-            raise self._stream.error
+            raise fresh_exc(self._stream.error) from self._stream.error  # a copy per raise (exceptions.fresh_exc)
 
     def read(self) -> Awaitable[bytes]:
         return read_all(self.aiter_bytes())

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h2/share.py

@@ -10,6 +10,7 @@ Cross-reference: `h2 ...` comments cite hyperium/h2 v0.4.15.
 """
 
 from .._httpunk import H2Reason
+from ..exceptions import fresh_exc
 
 
 class H2ResponseBody:
@@ -44,7 +45,10 @@ class H2ResponseBody:
             await self._manager.release_capacity(self._stream, len(chunk))
             yield chunk
         if self._stream.error is not None:
-            raise self._stream.error
+            # A copy per raise — many readers may surface the one stored stream/conn
+            # error, and a shared raised instance would accumulate every consumer's
+            # frames onto its traceback (exceptions.fresh_exc).
+            raise fresh_exc(self._stream.error) from self._stream.error
 
     async def aclose(self):
         """Cancel the stream if its body wasn't fully read (sends RST_STREAM).

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/h2/streams.py

@@ -26,7 +26,7 @@ import threading
 
 from .._common import aiter_body
 from .._httpunk import H2FlowControl
-from ..exceptions import H2FlowControlError, H2ProtocolError, H2Reason, StreamResetError
+from ..exceptions import H2FlowControlError, H2ProtocolError, H2Reason, StreamResetError, fresh_exc
 from .settings import PeerSettings
 
 
@@ -314,9 +314,9 @@ class StreamManager:
             # error to the parked sender). `_abort_stream`/`reset_stream`/
             # `recv_reset` set window_evt to wake us for this re-check.
             if st.error is not None:
-                raise st.error
+                raise fresh_exc(st.error) from st.error  # a copy per raise (exceptions.fresh_exc)
             if self._conn.error is not None:
-                raise self._conn.error
+                raise fresh_exc(self._conn.error) from self._conn.error
             if st.state.is_closed():
                 raise StreamResetError(st.id, int(H2Reason.CANCEL))
             with self._send_window_lock:

{httpunk-0.2.1 → httpunk-0.2.2}/httpunk/util/pool.py

@@ -31,6 +31,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 from .. import _backend
+from ..exceptions import fresh_exc
 
 
 class Canceled(Exception):  # noqa: N818 - `Canceled` is hyper-util's exact name (singleton.rs)
@@ -89,7 +90,9 @@ class Singleton:
             except BaseException as exc:
                 with self._lock:
                     self._state = "empty"  # ditch the round so the next get() retries
-                    self._error = exc
+                    # A stripped copy — the caught instance keeps propagating below
+                    # and this pool object is long-lived (exceptions.fresh_exc).
+                    self._error = fresh_exc(exc)
                 ready.set()
                 raise
             with self._lock:

httpunk-0.2.2/tests/test_error_retention.py

@@ -0,0 +1,183 @@
+"""The stored-error hygiene rules (`exceptions.fresh_exc`): saved connection/
+stream errors are traceback-free copies, and every raise of a saved error is a
+fresh copy chained to it — so no stored instance ever accumulates a consumer
+stack's frames into a refcount-invisible cycle (the class of bug where a failed
+connection's error pinned live transports until a gen-2 cyclic GC)."""
+
+import gc
+import platform
+import weakref
+
+import pytest
+
+from httpunk._backend.asyncio import AsyncioBackend, _AsyncioStream
+from httpunk.exceptions import GoAwayError, H2Reason, StreamResetError, fresh_exc
+from httpunk.h1.client import Connection as H1Driver
+
+
+# ----- fresh_exc -----
+
+
+def _caught(exc):
+    """Raise + catch `exc` so it carries a traceback, like any stored real error."""
+    try:
+        raise exc
+    except type(exc) as e:
+        return e
+
+
+def test_fresh_exc_copies_oserror_family():
+    err = _caught(ConnectionResetError(54, "Connection reset by peer"))
+    cp = fresh_exc(err)
+    assert cp is not err
+    assert type(cp) is ConnectionResetError
+    assert cp.args == err.args
+    assert (cp.errno, cp.strerror) == (54, "Connection reset by peer")
+    assert cp.__traceback__ is None  # the copy starts frame-free
+    assert err.__traceback__ is not None  # the original is untouched
+
+
+def test_fresh_exc_carries_dict_extras():
+    err = ValueError("poisoned")
+    err.request_unsent = True
+    cp = fresh_exc(err)
+    assert cp is not err
+    assert cp.request_unsent is True
+
+
+def test_fresh_exc_goaway_roundtrip():
+    # GoAwayError's args hold the formatted message, so copying needs its
+    # __reduce__ — with both a known (enum) and an unknown (raw int) error code.
+    for code in (int(H2Reason.ENHANCE_YOUR_CALM), 0x5EAF00D):
+        err = _caught(GoAwayError(7, code, b"bye"))
+        cp = fresh_exc(err)
+        assert cp is not err
+        assert type(cp) is GoAwayError
+        assert (cp.last_stream_id, cp.error_code, cp.debug_data) == (err.last_stream_id, err.error_code, b"bye")
+        assert str(cp) == str(err)
+        assert cp.__traceback__ is None
+
+
+def test_fresh_exc_stream_reset_roundtrip():
+    err = _caught(StreamResetError(5, int(H2Reason.CANCEL)))
+    cp = fresh_exc(err)
+    assert cp is not err
+    assert (cp.stream_id, cp.error_code) == (5, H2Reason.CANCEL)
+    assert cp.__traceback__ is None
+
+
+def test_fresh_exc_degrades_to_shared_instance():
+    class OddError(Exception):
+        def __init__(self, a, b):  # args don't roundtrip (message-only super().__init__)
+            super().__init__(f"{a}-{b}")
+
+    err = OddError(1, 2)
+    assert fresh_exc(err) is err  # uncopyable -> degraded but functional
+
+
+# ----- the asyncio backend stream -----
+
+
+@pytest.mark.asyncio
+async def test_connection_lost_strips_stored_traceback():
+    s = _AsyncioStream()
+    s.connection_made(None)
+    s.connection_lost(_caught(ConnectionResetError(54, "peer reset")))
+    assert s._error.__traceback__ is None
+
+
+@pytest.mark.asyncio
+async def test_receive_some_raises_a_fresh_copy():
+    s = _AsyncioStream()
+    s.connection_made(None)
+    s.connection_lost(ConnectionResetError(54, "peer reset"))
+    with pytest.raises(ConnectionResetError) as ei:
+        await s.receive_some()
+    assert ei.value is not s._error  # never the stored instance
+    assert ei.value.__cause__ is s._error  # chained for debuggability
+    assert ei.value.args == s._error.args
+    assert s._error.__traceback__ is None  # the raise left no frames on the stored error
+
+
+@pytest.mark.asyncio
+async def test_send_all_raises_a_fresh_copy():
+    s = _AsyncioStream()
+    s.connection_made(None)
+    s.connection_lost(ConnectionResetError(54, "peer reset"))
+    with pytest.raises(ConnectionResetError) as ei:
+        await s.send_all(b"data")
+    assert ei.value is not s._error
+    assert s._error.__traceback__ is None
+
+
+class _Sentinel:
+    """Stands in for everything a consumer frame holds (a server's response
+    transport, a relay generator, ...)."""
+
+
+@pytest.mark.skipif(
+    platform.python_implementation() != "CPython",
+    reason="asserts prompt refcount finalization — CPython semantics; on PyPy everything waits for GC regardless",
+)
+@pytest.mark.asyncio
+async def test_failed_stream_frees_consumer_state_without_cyclic_gc():
+    # The end-to-end property (the "s04" regression): after a consumer stack
+    # catches the read error of a failed connection, everything — the consumer's
+    # state AND the stream itself — must be freed by refcounting alone. Before
+    # the fresh_exc rules, the stored error's traceback closed a cycle through
+    # the stream and pinned the whole graph until a gen-2 collection.
+    s = _AsyncioStream()
+    s.connection_made(None)
+    s.connection_lost(ConnectionResetError(54, "peer reset"))
+    stream_ref = weakref.ref(s)
+    sentinel = _Sentinel()
+    sentinel_ref = weakref.ref(sentinel)
+
+    async def relay(stream, held):
+        try:
+            while True:
+                await stream.receive_some()
+        except ConnectionResetError:
+            pass  # swallowed, like a server relaying this body would
+
+    gc.disable()
+    try:
+        await relay(s, sentinel)
+        del sentinel
+        assert sentinel_ref() is None  # consumer state: freed by refcount
+        del s
+        assert stream_ref() is None  # the stream: no self-pinning cycle either
+    finally:
+        gc.enable()
+
+
+# ----- the h1 driver's saved connection error -----
+
+
+class _DummyTransport:
+    def close(self):
+        pass
+
+
+@pytest.mark.asyncio
+async def test_h1_fail_stores_a_stripped_copy():
+    # `_fail` runs while the caught instance is still propagating to the caller
+    # (send_request stores, then re-raises) — the saved error must be a copy so
+    # the continuing propagation can't grow a stored traceback.
+    conn = H1Driver(_DummyTransport(), backend=AsyncioBackend())
+    err = _caught(ValueError("mid-exchange failure"))
+    conn._fail(err)
+    assert conn.error is not err
+    assert conn.error.args == err.args
+    assert conn.error.__traceback__ is None
+
+
+@pytest.mark.asyncio
+async def test_h1_wait_idle_raises_a_fresh_copy():
+    conn = H1Driver(_DummyTransport(), backend=AsyncioBackend())
+    conn._fail(_caught(ValueError("dead")))
+    with pytest.raises(ValueError) as ei:
+        await conn.wait_idle()
+    assert ei.value is not conn.error
+    assert ei.value.__cause__ is conn.error
+    assert conn.error.__traceback__ is None  # this raise added nothing to the stored error

{httpunk-0.2.1 → httpunk-0.2.2}/tests/test_h1_server.py

@@ -502,7 +502,9 @@ async def test_server_upgrade_tunnel():
         s.spawn(serve())
         transport = await _raw_client(host, port)
         try:
-            await transport.send_all(b"GET /chat HTTP/1.1\r\nhost: x\r\nconnection: upgrade\r\nupgrade: myproto\r\n\r\n")
+            await transport.send_all(
+                b"GET /chat HTTP/1.1\r\nhost: x\r\nconnection: upgrade\r\nupgrade: myproto\r\n\r\n"
+            )
             head = await _read_until(transport, b"\r\n\r\n")
             assert head.startswith(b"HTTP/1.1 101")
             await transport.send_all(b"ping")