httpunk 0.1.0a2__tar.gz → 0.1.2__tar.gz

{httpunk-0.1.0a2 → httpunk-0.1.2}/Cargo.lock

@@ -16,9 +16,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bytes"
-version = "1.11.1"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "equivalent"
@@ -86,9 +86,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "http"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+checksum = "6970f50e31d6fc17d3fa27329444bfa74e196cf62e95052a3f6fee181dba6425"
 dependencies = [
  "bytes",
  "itoa",
@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.1.0-alpha2"
+version = "0.1.2"
 dependencies = [
  "bytes",
  "h2",
@@ -175,9 +175,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "libc"
-version = "0.2.183"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "once_cell"
@@ -271,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.45"
+version = "1.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
 dependencies = [
  "proc-macro2",
 ]
@@ -292,9 +292,9 @@ checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
 
 [[package]]
 name = "syn"
-version = "2.0.117"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
  "proc-macro2",
  "quote",

{httpunk-0.1.0a2 → httpunk-0.1.2}/Cargo.toml

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

{httpunk-0.1.0a2 → httpunk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.1.0a2
+Version: 0.1.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Dist: tonio~=0.7.1 ; python_full_version >= '3.14' and extra == 'tonio'
+Requires-Dist: tonio~=0.8.1 ; python_full_version >= '3.14' and extra == 'tonio'
 Provides-Extra: tonio
 License-File: LICENSE
 Summary: The Rust HTTP library for Python
@@ -265,6 +265,13 @@ h.get_all("set-cookie")      # [b'a=1', b'b=2']
 Anywhere a `headers=` argument is accepted you can pass a `HeaderMap`, a mapping, or an
 iterable of `(name, value)` pairs.
 
+For consumers that want raw pairs — e.g. an ASGI server building a scope's `headers` —
+`raw_items()` returns `(bytes, bytes)` tuples (names already lowercase) in one call:
+
+```python
+h.raw_items()                # [(b'content-type', b'text/plain'), (b'set-cookie', b'a=1'), ...]
+```
+
 ### Errors
 
 httpunk's exceptions all derive from a common `HTTPunkError` root. `ConnectionClosedError`

{httpunk-0.1.0a2 → httpunk-0.1.2}/README.md

@@ -230,6 +230,13 @@ h.get_all("set-cookie")      # [b'a=1', b'b=2']
 Anywhere a `headers=` argument is accepted you can pass a `HeaderMap`, a mapping, or an
 iterable of `(name, value)` pairs.
 
+For consumers that want raw pairs — e.g. an ASGI server building a scope's `headers` —
+`raw_items()` returns `(bytes, bytes)` tuples (names already lowercase) in one call:
+
+```python
+h.raw_items()                # [(b'content-type', b'text/plain'), (b'set-cookie', b'a=1'), ...]
+```
+
 ### Errors
 
 httpunk's exceptions all derive from a common `HTTPunkError` root. `ConnectionClosedError`

{httpunk-0.1.0a2 → httpunk-0.1.2}/httpunk/_backend/asyncio.py

@@ -162,6 +162,12 @@ class _AsyncioStream(asyncio.Protocol):
         if waiter is not None and not waiter.done():
             waiter.set_result(None)
 
+    def interrupt_read(self):
+        """Wake a parked `receive_some` so it returns b"" — lets a graceful shutdown release
+        an idle keep-alive read WITHOUT racing a coroutine (asyncio can wake a parked read from
+        another task; tonio can't, which is why it uses a select-based race instead)."""
+        self._wake_reader()
+
 
 class _AsyncioScope:
     """A nursery over `asyncio` tasks, matching tonio's scope surface: `spawn`,
@@ -297,3 +303,18 @@ class AsyncioBackend:
     scope = _AsyncioScope
     monotonic = staticmethod(_time.monotonic)
     sleep = staticmethod(asyncio.sleep)  # async sleep(seconds), for deadline races (`select`)
+
+    # Every backend implements `timeout` (above), so the h1 server always uses it for the
+    # head-read deadline. This extra capability is asyncio-only: `_AsyncioStream.interrupt_read`
+    # can wake a parked idle read from another task, so the h1 server can skip the per-read
+    # shutdown `select`. tonio can't (no such method) → it keeps the select there.
+    native_read_interrupt = True
+
+    async def timeout(self, coro, seconds):
+        """Run `coro` bounded by `seconds`; return `(result, True)` on completion, or
+        `(None, False)` on timeout (the coro is cancelled). One task + one timer, far cheaper
+        than racing a `sleep()` coroutine via `select`."""
+        try:
+            return await asyncio.wait_for(coro, seconds), True
+        except (TimeoutError, asyncio.TimeoutError):
+            return None, False

{httpunk-0.1.0a2 → httpunk-0.1.2}/httpunk/_backend/tonio.py

@@ -12,7 +12,7 @@ from tonio.colored.net import open_tcp_stream as _open_tcp_stream
 from tonio.colored.net.tls import open_tls_over_tcp_stream as _open_tls_over_tcp_stream
 from tonio.colored.sync import Lock as _Lock, Semaphore as _Semaphore
 from tonio.colored.sync.channel import unbounded as _unbounded
-from tonio.colored.time import time as _now
+from tonio.colored.time import time as _now, timeout as _timeout
 
 
 class _TonioSemaphore:
@@ -107,4 +107,9 @@ class TonioBackend:
     semaphore = _TonioSemaphore
     queue = staticmethod(_unbounded)
     monotonic = staticmethod(_now)
-    sleep = staticmethod(_colored.sleep)  # async sleep(seconds), for deadline races (`select`)
+    sleep = staticmethod(_colored.sleep)  # async sleep(seconds)
+    # `timeout(coro, seconds) -> (result, completed)` — tonio's native deadline; the h1 server
+    # uses it to bound the request-head read (measured ~12-16% faster than racing sleep() via
+    # select). Same contract as AsyncioBackend.timeout. tonio still can't wake a parked recv from
+    # another task, so it does NOT advertise `native_read_interrupt` (idle shutdown stays select).
+    timeout = staticmethod(_timeout)

{httpunk-0.1.0a2 → httpunk-0.1.2}/httpunk/_httpunk.pyi

@@ -88,6 +88,11 @@ class HeaderMap:
     def items(self) -> list[tuple[str, bytes]]:
         """Every `(name, value)` pair, in order (duplicates included)."""
 
+    def raw_items(self) -> list[tuple[bytes, bytes]]:
+        """Every `(name, value)` pair with the name as raw `bytes` (already lowercase
+        ASCII), in order, duplicates included — the exact shape ASGI servers want for a
+        scope's `headers`, in one boundary crossing with no per-name re-encoding."""
+
     def __iter__(self) -> Iterator[str]: ...
     def __len__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...

{httpunk-0.1.0a2 → httpunk-0.1.2}/httpunk/h1/server.py

@@ -53,7 +53,6 @@ _CONTINUE = b"HTTP/1.1 100 Continue\r\n\r\n"
 # (io.rs: 8192 + 4096*100). Bounds per-connection memory against a slow/oversized head.
 _MAX_HEAD_SIZE = 8192 + 4096 * 100
 _DEFAULT_HEADER_READ_TIMEOUT = 30.0  # hyper's `header_read_timeout` default (http1.rs L249)
-_TIMED_OUT = object()  # sentinel: the header read exceeded `header_read_timeout`
 # The HTTP/2 connection preface (client prior-knowledge). An h1 server that sees it
 # closes silently with a version error rather than writing a 400 (hyper `on_parse_error`
 # -> `has_h2_prefix` -> `new_version_h2`, conn.rs L29/L809-812).
@@ -174,6 +173,22 @@ class ServerRequest:
         self._responded = True
         await self._conn.send_response(self, status, headers, body)
 
+    def detach(self) -> bytes:
+        """Take over the raw connection for a protocol upgrade (WebSocket, or a custom protocol):
+        stop the server's accept loop and relinquish the transport WITHOUT closing it, returning
+        any bytes already read past the request head (to replay). The caller — which supplied the
+        transport to `H1Server` — owns it afterwards and must drive the upgrade itself (httpunk
+        sends no response). Like httpunk's 101/CONNECT tunnel hand-off, but caller-driven.
+
+        After this, the accept loop ends (`next_request` returns None) and the server's close on
+        `__aexit__` is a no-op, so the transport stays open. cf. Go's `http.Hijacker`."""
+        if self._responded:
+            raise RuntimeError("cannot detach: a response was already sent for this request")
+        self._responded = True
+        leftover = self._decoder.take_buffered()
+        self._conn._detach()
+        return leftover
+
     def __repr__(self) -> str:
         return f"ServerRequest(method={self.method!r}, target={self.target!r})"
 
@@ -193,6 +208,12 @@ class ServerConnection(H1ConnectionBase):
         # Max time to read a complete request head before closing (slowloris defence),
         # hyper's `header_read_timeout` (default 30s, http1.rs L249). `None` disables it.
         self._header_read_timeout = header_read_timeout
+        # The head-read deadline always uses `backend.timeout` (every backend implements it).
+        # This capability is extra: a backend that can wake a parked read from another task
+        # (asyncio) lets us skip the per-read shutdown `select`; absent (tonio) → use `select`.
+        # See `_read_or_shutdown` + `graceful_shutdown`.
+        self._native_read_interrupt = getattr(self.backend, "native_read_interrupt", False)
+        self._idle_read_parked = False  # True only while parked in the idle between-requests read
 
     async def start(self):
         pass  # HTTP/1 has no connection preface / handshake
@@ -206,6 +227,10 @@ class ServerConnection(H1ConnectionBase):
         # loop to completion and closes; nothing is awaited/closed here.
         self._reusable = False
         self._shutdown_evt.set()
+        if self._native_read_interrupt and self._idle_read_parked:
+            # asyncio: wake the read parked idly between requests so it returns promptly and
+            # the connection closes, instead of relying on a per-read select race (tonio's path).
+            self.transport.interrupt_read()
 
     def mark_unusable(self):
         self._reusable = False
@@ -314,22 +339,17 @@ class ServerConnection(H1ConnectionBase):
         return False
 
     async def _read_request_head(self, codec, initial=b""):
-        # Bound the head read by `header_read_timeout` (slowloris defence, hyper
-        # http1.rs L249): race the read against a deadline; if it wins, close with no
-        # response (hyper closes on a header-read timeout). `select` cancels the losing
-        # branch, cleanly dropping the parked read. `None` disables the timeout.
-        # NIT (design cleanup, deferred): this `sleep` + `select` deadline could become a
-        # normalized `backend.timeout(coro, seconds)` primitive — more direct, no
-        # sentinel / nested select. Kept as-is for now (see TODONOTES).
+        # Bound the head read by `header_read_timeout` (slowloris defence, hyper http1.rs L249):
+        # if the deadline wins, close with no response (hyper closes on a header-read timeout).
+        # `backend.timeout(coro, seconds) -> (result, completed)` cancels the read cleanly on
+        # expiry — cheap on every backend (asyncio: one task + one timer; tonio: its native
+        # timeout). `None` disables the deadline.
         if self._header_read_timeout is None:
             return await self._read_head_frames(codec, initial)
-
-        async def _deadline():
-            await self.backend.sleep(self._header_read_timeout)
-            return _TIMED_OUT
-
-        result = await self.backend.select(self._read_head_frames(codec, initial), _deadline())
-        if result is _TIMED_OUT:
+        result, completed = await self.backend.timeout(
+            self._read_head_frames(codec, initial), self._header_read_timeout
+        )
+        if not completed:
             self._closed = True
             self._reusable = False
             self._close_transport()
@@ -352,13 +372,22 @@ class ServerConnection(H1ConnectionBase):
         idle = not initial  # no bytes of this request seen yet -> a graceful shutdown may end it
         while True:
             if idle:
-                # Between requests: race the read against a graceful-shutdown signal
-                # so an idle keep-alive connection completes promptly (tonio can't
-                # wake a parked recv from another task; hyper's poll re-checks
-                # `should_read` and completes instead of reading).
-                data = await self._read_or_shutdown(_READ_SIZE)
-                if data is _SHUTDOWN:
+                # Between requests: a graceful shutdown may end the wait (see
+                # `_read_or_shutdown` — sync; returns the sentinel or the read awaitable).
+                read = self._read_or_shutdown(_READ_SIZE)
+                if read is _SHUTDOWN:
+                    return None
+                # Flag the park as idle so graceful_shutdown() may wake THIS read only —
+                # never a mid-head read (a request in flight must complete).
+                self._idle_read_parked = True
+                try:
+                    data = await read
+                finally:
+                    self._idle_read_parked = False
+                if data is _SHUTDOWN:  # tonio select: the shutdown signal won the race
                     return None
+                # An interrupt_read shutdown wake surfaces as b"" and falls into the EOF
+                # return below — same outcome either way (loop ends; close, no response).
             else:
                 data = await self.transport.receive_some(_READ_SIZE)
             if not data:
@@ -383,13 +412,24 @@ class ServerConnection(H1ConnectionBase):
             if buffered >= _MAX_HEAD_SIZE:
                 raise ValueError("message head is too large (Parse::TooLarge)")
 
-    async def _read_or_shutdown(self, n):
-        # Read the next head byte(s), or `_SHUTDOWN` if `graceful_shutdown()` fires
-        # first. The backend's `select` cancels the losing branch, so the parked read
-        # is cleanly dropped when shutdown wins.
+    def _read_or_shutdown(self, n):
+        """The next idle-read awaitable, or `_SHUTDOWN` if a graceful shutdown was already
+        requested. A plain (sync) function so the fast path adds no wrapper coroutine: the
+        caller awaits the returned awaitable with `_idle_read_parked` set around it (so
+        `graceful_shutdown()` wakes only an idly-parked read, never a mid-head one) and
+        treats an awaited `_SHUTDOWN` — or a woken `b""` — as shutdown, not data.
+
+        asyncio (`native_read_interrupt`): a plain read; if it parks, graceful_shutdown()
+        wakes it via `interrupt_read` and the read returns b"". Backends without a native
+        read interrupt (tonio can't wake a parked recv from another task): race the read
+        against the shutdown signal via `select`, which cancels the losing branch — hyper's
+        poll instead re-checks `should_read` and completes without reading."""
         if self._shutdown_evt.is_set():
             return _SHUTDOWN
 
+        if self._native_read_interrupt:
+            return self.transport.receive_some(n)
+
         def _recv():
             return self.transport.receive_some(n)
 
@@ -397,7 +437,7 @@ class ServerConnection(H1ConnectionBase):
             await self._shutdown_evt.wait()
             return _SHUTDOWN
 
-        return await self.backend.select(_recv(), _await_shutdown())
+        return self.backend.select(_recv(), _await_shutdown())
 
     async def _send_error(self, codec, status):
         """Best-effort automatic error response (bodyless, `Connection: close`),

{httpunk-0.1.0a2 → httpunk-0.1.2}/pyproject.toml

@@ -36,7 +36,7 @@ requires-python = ">=3.10"
 dependencies = []
 
 [project.optional-dependencies]
-tonio = ["tonio~=0.7.1; python_version >= '3.14'"]
+tonio = ["tonio~=0.8.1; python_version >= '3.14'"]
 
 [dependency-groups]
 build = [

{httpunk-0.1.0a2 → httpunk-0.1.2}/src/http/mod.rs

@@ -238,6 +238,22 @@ impl HeaderMap {
         Ok(self.items_list(py)?.unbind())
     }
 
+    /// Every `(name, value)` pair with the name as raw `bytes` (already lowercase
+    /// ASCII in the `http` crate), in order, duplicates included — the exact shape
+    /// ASGI servers want for a scope's `headers`, in one boundary crossing and with
+    /// no per-name re-encoding.
+    fn raw_items(&self, py: Python<'_>) -> PyResult<Py<PyList>> {
+        let guard = self.inner.lock().unwrap();
+        let list = PyList::empty(py);
+        for (name, value) in guard.iter() {
+            list.append((
+                PyBytes::new(py, name.as_str().as_bytes()),
+                PyBytes::new(py, value.as_bytes()),
+            ))?;
+        }
+        Ok(list.unbind())
+    }
+
     fn __iter__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let list = PyList::new(py, self.keys())?;
         Ok(list.try_iter()?.into_any().unbind())

{httpunk-0.1.0a2 → httpunk-0.1.2}/tests/test_h1_server.py

@@ -9,6 +9,7 @@ from _client import open_h1
 from tonio.colored import scope
 from tonio.colored.net import open_tcp_listeners
 
+from httpunk._backend.asyncio import AsyncioBackend
 from httpunk._backend.tonio import TonioBackend
 from httpunk.exceptions import ConnectionClosedError
 from httpunk.h1 import H1Server
@@ -77,6 +78,22 @@ class _StubTransport:
         self.closed = True
 
 
+class _PeekableStub(_StubTransport):
+    """A stub whose SECOND payload becomes readable only after the first is consumed —
+    models a pipelined request sitting buffered in the transport while the previous
+    request is being served."""
+
+    def __init__(self, first, buffered):
+        super().__init__(first)
+        self._buffered = buffered
+
+    async def receive_some(self, max_bytes=65536):
+        if self._data:
+            return await super().receive_some(max_bytes)
+        chunk, self._buffered = self._buffered[:max_bytes], self._buffered[max_bytes:]
+        return chunk
+
+
 async def _echo_server(listener, seen=None):
     """Accept one connection; echo each request as 200 `b"<METHOD> <target> -> " + body`."""
     transport = await listener.accept()
@@ -276,6 +293,55 @@ async def test_server_header_read_timeout_closes_slow_head():
         s.cancel()
 
 
+@pytest.mark.asyncio
+async def test_server_shutdown_wins_over_buffered_pipelined_request():
+    """REGRESSION GUARD: a graceful-shutdown signal is honored BEFORE any idle read consumes
+    already-buffered bytes — hyper stops parsing new heads once keep-alive is disabled
+    (`can_read_head` under KA::Disabled), so a pipelined request already sitting in the
+    transport must NOT be served. Whitebox: the shutdown event is set directly (without
+    `graceful_shutdown()`'s `_reusable = False`, which would end the accept loop before the
+    read even starts) to pin the in-loop ordering: shutdown check -> read."""
+    transport = _PeekableStub(
+        b"GET /a HTTP/1.1\r\nhost: x\r\n\r\n",
+        b"GET /b HTTP/1.1\r\nhost: x\r\n\r\n",
+    )
+    conn = ServerConnection(transport, backend=AsyncioBackend())
+    req = await conn.next_request()
+    assert req.target == "/a"
+    await req.respond(200)
+    conn._shutdown_evt.set()  # signal only (whitebox) — see docstring
+    assert await conn.next_request() is None  # /b is readable but must NOT be parsed
+
+
+@pytest.mark.tonio
+async def test_server_detach_hands_off_open_connection():
+    """detach() stops the accept loop and relinquishes the transport WITHOUT closing it,
+    returning bytes read past the request head — so a caller can take over the raw connection
+    for a protocol upgrade (e.g. WebSocket)."""
+    listener, host, port = await _listener()
+    captured = {}
+
+    async def serve():
+        transport = await listener.accept()
+        async with H1Server(transport) as server:
+            async for req in server:
+                captured["leftover"] = req.detach()  # loop ends next (detached), socket stays open
+        # `__aexit__` ran (close() is a no-op after detach) — the transport is still usable, so
+        # the caller drives its own upgrade response on the raw connection.
+        await transport.send_all(b"HTTP/1.1 101 Switching Protocols\r\nupgrade: custom\r\n\r\nOWNED")
+
+    async with scope() as s:
+        s.spawn(serve())
+        client = await _raw_client(host, port)
+        # request head + trailing bytes the client sent past it (must survive as `leftover`)
+        await client.send_all(b"GET /up HTTP/1.1\r\nhost: x\r\nupgrade: custom\r\nconnection: upgrade\r\n\r\nEXTRA")
+        data = await _read_until(client, b"OWNED")
+        s.cancel()
+
+    assert captured["leftover"] == b"EXTRA"  # bytes past the head handed back
+    assert b"101 Switching Protocols" in data and data.endswith(b"OWNED")  # socket stayed open
+
+
 @pytest.mark.tonio
 async def test_server_no_100_continue_for_http10():
     """An HTTP/1.0 request never gets an auto 100-continue, even with `Expect:

httpunk-0.1.2/tests/test_headermap.py

@@ -0,0 +1,21 @@
+"""HeaderMap surface tests (Rust `http` crate wrapper) — currently just `raw_items`,
+the ASGI-shaped `(bytes, bytes)` view; the rest of the surface is exercised throughout
+the h1/h2 suites."""
+
+from httpunk import HeaderMap
+
+
+def test_raw_items_matches_items_with_bytes_names():
+    h = HeaderMap({"Content-Type": "text/plain"})
+    h.add("set-cookie", "a=1")
+    h.add("Set-Cookie", "b=2")  # names normalize to lowercase; duplicates kept in order
+
+    raw = h.raw_items()
+    assert raw == [(b"content-type", b"text/plain"), (b"set-cookie", b"a=1"), (b"set-cookie", b"b=2")]
+    # exact parity with items(), modulo the name type
+    assert raw == [(name.encode("latin-1"), value) for name, value in h.items()]
+    assert all(isinstance(n, bytes) and isinstance(v, bytes) for n, v in raw)
+
+
+def test_raw_items_empty():
+    assert HeaderMap().raw_items() == []