httpunk 0.1.0a2__tar.gz → 0.1.1__tar.gz

{httpunk-0.1.0a2 → httpunk-0.1.1}/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.1"
 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.1}/Cargo.toml

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.1.0a2
+Version: 0.1.1
 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

{httpunk-0.1.0a2 → httpunk-0.1.1}/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.1}/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.1}/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()
@@ -390,6 +410,20 @@ class ServerConnection(H1ConnectionBase):
         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`.
         def _recv():
             return self.transport.receive_some(n)
 

{httpunk-0.1.0a2 → httpunk-0.1.1}/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.1}/tests/test_h1_server.py

@@ -276,6 +276,35 @@ async def test_server_header_read_timeout_closes_slow_head():
         s.cancel()
 
 
+@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: