httpunk 0.1.1__tar.gz → 0.1.2__tar.gz

{httpunk-0.1.1 → httpunk-0.1.2}/Cargo.lock

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

{httpunk-0.1.1 → httpunk-0.1.2}/Cargo.toml

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

{httpunk-0.1.1 → httpunk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -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.1 → 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.1 → 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.1 → httpunk-0.1.2}/httpunk/h1/server.py

@@ -372,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:
@@ -403,27 +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:
-            # asyncio: a plain read; if it parks, graceful_shutdown() wakes it via
-            # `interrupt_read` (a shutdown-woken read returns b"") — no per-read select race.
-            self._idle_read_parked = True
-            try:
-                data = await self.transport.receive_some(n)
-            finally:
-                self._idle_read_parked = False
-            if not data and self._shutdown_evt.is_set():
-                return _SHUTDOWN
-            return data
-
-        # Backends without native read control (tonio can't wake a parked recv from another
-        # task): race the read against the shutdown signal via `select`.
+            return self.transport.receive_some(n)
+
         def _recv():
             return self.transport.receive_some(n)
 
@@ -431,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.1 → 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.1 → 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,26 @@ 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,

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() == []