without-http 0.0.4__tar.gz → 0.0.6__tar.gz

{without_http-0.0.4 → without_http-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: without-http
-Version: 0.0.4
+Version: 0.0.6
 Summary: A sans-IO-backed ASGI server and HTTP client for without: h11/h2/wsproto over asyncio sockets.
 Author: Josh Karpel
 Author-email: Josh Karpel <josh.karpel@gmail.com>
@@ -16,8 +16,9 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Dist: without-core==0.0.4
-Requires-Dist: without-asgi==0.0.4
+Requires-Dist: without-async==0.0.6
+Requires-Dist: without-streams==0.0.6
+Requires-Dist: without-asgi==0.0.6
 Requires-Dist: h11>=0.16
 Requires-Dist: h2>=4.1
 Requires-Dist: wsproto>=1.2
@@ -29,7 +30,7 @@ Description-Content-Type: text/markdown
 # without-http
 
 A sans-IO-backed ASGI **server** and **HTTP client** for `without`. Where
-[`without-asgi`](../without-asgi) is the *app* side of the ASGI boundary (it turns
+[`without-asgi`](../without_asgi) is the *app* side of the ASGI boundary (it turns
 a server's `receive`/`send` into typed streams), `without-http` is the *server*
 side: it owns the socket and the HTTP wire protocol, and drives any ASGI app via
 `app(scope, receive, send)`.
@@ -43,7 +44,7 @@ those state machines, and uses `without-asgi`'s server-direction codecs to
 translate between typed events and the ASGI dicts an app expects.
 
 ```python
-from without import sleep_forever
+from without_async import sleep_forever
 from without_asgi import make_asgi_app
 from without_http import ConnectionPool, request, serving
 

{without_http-0.0.4 → without_http-0.0.6}/README.md

@@ -1,7 +1,7 @@
 # without-http
 
 A sans-IO-backed ASGI **server** and **HTTP client** for `without`. Where
-[`without-asgi`](../without-asgi) is the *app* side of the ASGI boundary (it turns
+[`without-asgi`](../without_asgi) is the *app* side of the ASGI boundary (it turns
 a server's `receive`/`send` into typed streams), `without-http` is the *server*
 side: it owns the socket and the HTTP wire protocol, and drives any ASGI app via
 `app(scope, receive, send)`.
@@ -15,7 +15,7 @@ those state machines, and uses `without-asgi`'s server-direction codecs to
 translate between typed events and the ASGI dicts an app expects.
 
 ```python
-from without import sleep_forever
+from without_async import sleep_forever
 from without_asgi import make_asgi_app
 from without_http import ConnectionPool, request, serving
 

{without_http-0.0.4 → without_http-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "without-http"
-version = "0.0.4"
+version = "0.0.6"
 description = "A sans-IO-backed ASGI server and HTTP client for without: h11/h2/wsproto over asyncio sockets."
 readme = "README.md"
 license = "MIT"
@@ -23,8 +23,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "without-core==0.0.4",
-    "without-asgi==0.0.4",
+    "without-async==0.0.6",
+    "without-streams==0.0.6",
+    "without-asgi==0.0.6",
     "h11>=0.16",
     "h2>=4.1",
     "wsproto>=1.2",
@@ -36,7 +37,10 @@ dependencies = [
 name = "Josh Karpel"
 email = "josh.karpel@gmail.com"
 
-[tool.uv.sources.without-core]
+[tool.uv.sources.without-async]
+workspace = true
+
+[tool.uv.sources.without-streams]
 workspace = true
 
 [tool.uv.sources.without-asgi]

{without_http-0.0.4 → without_http-0.0.6}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "without-http"
-version = "0.0.4"
+version = "0.0.6"
 description = "A sans-IO-backed ASGI server and HTTP client for without: h11/h2/wsproto over asyncio sockets."
 readme = "README.md"
 license = "MIT"
@@ -26,8 +26,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "without-core==0.0.4",
-    "without-asgi==0.0.4",
+    "without-async==0.0.6",
+    "without-streams==0.0.6",
+    "without-asgi==0.0.6",
     "h11>=0.16",
     "h2>=4.1",
     "wsproto>=1.2",
@@ -36,5 +37,6 @@ dependencies = [
 ]
 
 [tool.uv.sources]
-without-core = { workspace = true }
+without-async = { workspace = true }
+without-streams = { workspace = true }
 without-asgi = { workspace = true }

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/__init__.py

@@ -1,4 +1,5 @@
 from without_http.client import DEFAULT_DECOMPRESSORS
+from without_http.client import GZIP_CONTAINER
 from without_http.client import USER_AGENT
 from without_http.client import Client
 from without_http.client import ClientMiddleware
@@ -13,10 +14,12 @@ from without_http.client import Resolve
 from without_http.client import ResponseBody
 from without_http.client import ResponseHead
 from without_http.client import ResponseTrailers
+from without_http.client import StreamingCompressor
 from without_http.client import add_headers
 from without_http.client import basic_auth
 from without_http.client import bearer_auth
 from without_http.client import brotli_compress
+from without_http.client import brotli_compressor
 from without_http.client import compressing
 from without_http.client import cookies
 from without_http.client import deadline
@@ -24,12 +27,14 @@ from without_http.client import decompress
 from without_http.client import default_headers
 from without_http.client import follow_redirects
 from without_http.client import gzip_compress
+from without_http.client import gzip_compressor
 from without_http.client import request
 from without_http.client import stack
 from without_http.client import tcp_connect
 from without_http.client import user_agent
 from without_http.client import wrap
 from without_http.client import zstd_compress
+from without_http.client import zstd_compressor
 from without_http.h2_wire import early_hint_headers
 from without_http.h2_wire import request_headers
 from without_http.h2_wire import response_headers
@@ -46,6 +51,11 @@ from without_http.socket_options import SocketOptions
 from without_http.socket_options import receive_buffer_size
 from without_http.socket_options import send_buffer_size
 from without_http.socket_options import tcp_keepalive
+from without_http.sse import DEFAULT_RECONNECT
+from without_http.sse import MAXIMUM_RECONNECT
+from without_http.sse import MINIMUM_RECONNECT
+from without_http.sse import NotAnEventStream
+from without_http.sse import subscribe
 from without_http.timeouts import ConnectTimeout
 from without_http.timeouts import HTTPTimeout
 from without_http.timeouts import PoolTimeout
@@ -64,6 +74,10 @@ from without_http.ws_wire import ws_events_from_outbound
 __all__ = [
     "ALPN_PROTOCOLS",
     "DEFAULT_DECOMPRESSORS",
+    "DEFAULT_RECONNECT",
+    "GZIP_CONTAINER",
+    "MAXIMUM_RECONNECT",
+    "MINIMUM_RECONNECT",
     "USER_AGENT",
     "Client",
     "ClientMiddleware",
@@ -77,6 +91,7 @@ __all__ = [
     "Decompressor",
     "HTTPTimeout",
     "LifespanError",
+    "NotAnEventStream",
     "PoolTimeout",
     "ReadTimeout",
     "Resolve",
@@ -85,12 +100,14 @@ __all__ = [
     "ResponseTrailers",
     "Server",
     "SocketOptions",
+    "StreamingCompressor",
     "Timeout",
     "WriteTimeout",
     "add_headers",
     "basic_auth",
     "bearer_auth",
     "brotli_compress",
+    "brotli_compressor",
     "compressing",
     "cookies",
     "deadline",
@@ -101,6 +118,7 @@ __all__ = [
     "extensions_with_tls",
     "follow_redirects",
     "gzip_compress",
+    "gzip_compressor",
     "h11_events_from_outbound",
     "inbound_from_event",
     "is_websocket_upgrade",
@@ -116,6 +134,7 @@ __all__ = [
     "server_ssl_context",
     "serving",
     "stack",
+    "subscribe",
     "tcp_connect",
     "tcp_keepalive",
     "tls_extension",
@@ -124,4 +143,5 @@ __all__ = [
     "wrap",
     "ws_events_from_outbound",
     "zstd_compress",
+    "zstd_compressor",
 ]

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/client.py

@@ -23,6 +23,7 @@ from datetime import datetime
 from datetime import timedelta
 from email.utils import parsedate_to_datetime
 from importlib import metadata
+from types import MappingProxyType
 from typing import NamedTuple
 from typing import Protocol
 from typing import Self
@@ -38,14 +39,20 @@ import h2.exceptions
 import h11
 from aiohappyeyeballs import AddrInfoType
 from aiohappyeyeballs import start_connection
-from without import Endo
-from without import Stream
-from without import cancel_futures
-from without import stack
 from without_asgi import Content
 from without_asgi import RawHeaders
 from without_asgi import StreamingContent
+from without_asgi.compression import GZIP_CONTAINER
+from without_asgi.compression import Compressor
+from without_asgi.compression import StreamingCompressor
+from without_asgi.compression import brotli_compressor
+from without_asgi.compression import gzip_compressor
+from without_asgi.compression import zstd_compressor
 from without_asgi.headers import merge
+from without_async import cancel_futures
+from without_streams import Endo
+from without_streams import Stream
+from without_streams import stack
 
 from without_http.h2_wire import request_headers
 from without_http.h2_wire import response_status_and_headers
@@ -1615,26 +1622,28 @@ def follow_redirects(max_hops: int = 5) -> ClientMiddleware:
 
 
 _REQUEST_FRAMING_HEADERS = frozenset({b"content-length", b"transfer-encoding"})
-_GZIP_CONTAINER = zlib.MAX_WBITS | 16  # the wbits offset that selects the gzip wrapper around DEFLATE
-
-
-class Compressor(Protocol):
-    """
-    The incremental compressor shape `compressing` drives: feed chunks through
-    `compress`, then `flush` ends the stream. `zlib.compressobj` and
-    `zstd.ZstdCompressor` satisfy it as-is; a third-party codec plugs in with
-    whatever thin adapter its own surface needs.
-    """
-
-    def compress(self, data: bytes, /) -> bytes: ...
-    def flush(self) -> bytes: ...
 
 
 async def _compressed(body: Stream[bytes], compressor: Compressor) -> AsyncIterator[bytes]:
+    # A codec decides for itself what any one `compress` call returns, and fed the
+    # pieces a streamed body arrives in it usually returns nothing, holding the whole
+    # upload until the stream ends. Ending a block per chunk is what releases it; a
+    # codec with no way to do that (a plain `Compressor`) has to hold it, since unlike
+    # a negotiated response there is no unencoded answer available to a caller who
+    # asked for this coding by name.
+    flush_block: Callable[[], bytes] = (
+        compressor.flush_block if isinstance(compressor, StreamingCompressor) else lambda: b""
+    )
+    # One chunk of lookahead, so the last one is known to be last and rides out on the
+    # flush that ends the stream rather than paying for a block of its own. A body that
+    # arrives whole is one chunk, so it still encodes to exactly the bytes it would
+    # have without any of this.
+    held: bytes | None = None
     async for chunk in body:
-        if compressed := compressor.compress(chunk):
+        if held and (compressed := compressor.compress(held) + flush_block()):
             yield compressed
-    yield compressor.flush()
+        held = chunk
+    yield compressor.compress(held or b"") + compressor.flush()
 
 
 def compressing(coding: bytes, make_compressor: Callable[[], Compressor]) -> ClientMiddleware:
@@ -1648,11 +1657,21 @@ def compressing(coding: bytes, make_compressor: Callable[[], Compressor]) -> Cli
     reimplemented.
 
     That rest: the lazy body `Stream[bytes]` is wrapped in the incremental compressor,
-    so a streamed upload compresses chunk by chunk and nothing buffers; and the
-    framing follows the rewrite, `content-length` no longer describes the body, so it
-    is dropped and the compressed stream goes out `transfer-encoding: chunked` (over
-    HTTP/2 the framing header is dropped with the other hop-by-hop headers and the
-    body rides DATA frames as usual).
+    so a streamed upload compresses chunk by chunk and holds no more than one of them;
+    and the framing follows the rewrite, `content-length` no longer describes the body,
+    so it is dropped and the compressed stream goes out `transfer-encoding: chunked`
+    (over HTTP/2 the framing header is dropped with the other hop-by-hop headers and
+    the body rides DATA frames as usual).
+
+    Holding no more than a chunk is a demand on the codec, not just on the loop: what
+    `compress` returns is the codec's choice, and fed a chunk at a time zlib and zstd
+    return almost nothing until the stream ends, which would buffer the whole upload
+    inside the codec while looking like it streamed. `make_compressor` should therefore
+    produce a `StreamingCompressor`, as `gzip_compressor`, `zstd_compressor`, and
+    `brotli_compressor` all do; a plain `Compressor` still encodes correctly and still
+    buffers, because a coding named by the caller has no unencoded answer to fall back
+    on the way a negotiated response does. A body that arrives whole is one chunk
+    either way, and encodes to the same bytes under both.
 
     Two kinds of request pass through untouched: one already carrying a
     `content-encoding` (the body is already encoded; re-compressing would corrupt it),
@@ -1694,7 +1713,7 @@ def gzip_compress(level: int = zlib.Z_DEFAULT_COMPRESSION) -> ClientMiddleware:
     codings, and `compressing` is the shared mechanism for any coding beyond those;
     the response-side counterpart to all of them is `decompress`.
     """
-    return compressing(b"gzip", lambda: zlib.compressobj(level, zlib.DEFLATED, _GZIP_CONTAINER))
+    return compressing(b"gzip", lambda: gzip_compressor(level))
 
 
 def zstd_compress(level: int | None = None) -> ClientMiddleware:
@@ -1708,33 +1727,7 @@ def zstd_compress(level: int | None = None) -> ClientMiddleware:
 
     `level` is zstd's compression level, defaulting to the library's own default.
     """
-    return compressing(b"zstd", lambda: zstd.ZstdCompressor(level))
-
-
-class _RawBrotliCompressor(Protocol):
-    """The slice of `brotli.Compressor` the adapter drives (the bindings ship no types)."""
-
-    def process(self, data: bytes, /) -> bytes: ...
-    def finish(self) -> bytes: ...
-
-
-@dataclass(slots=True, eq=False)
-class _BrotliCompressor:
-    """
-    Adapt `brotli.Compressor` to the `Compressor` shape.
-
-    Brotli's bindings spell the incremental surface `process`/`finish` (their `flush`
-    is a mid-stream flush that keeps the stream open), so the adapter maps `compress`
-    to `process` and `flush` to `finish`.
-    """
-
-    _raw: _RawBrotliCompressor
-
-    def compress(self, data: bytes, /) -> bytes:
-        return self._raw.process(data)
-
-    def flush(self) -> bytes:
-        return self._raw.finish()
+    return compressing(b"zstd", lambda: zstd_compressor(level))
 
 
 def brotli_compress(quality: int = 11) -> ClientMiddleware:
@@ -1744,9 +1737,12 @@ def brotli_compress(quality: int = 11) -> ClientMiddleware:
     `gzip_compress`'s sibling over brotli ([Google's own bindings](https://github.com/google/brotli),
     a bundled dependency since the stdlib has no brotli): everything there holds here,
     and only the coding differs. `quality` is brotli's compression quality (0-11),
-    defaulting to the library's own default (11, the maximum).
+    defaulting to the bindings' own default of 11, the maximum, because a client
+    compressing an upload it holds whole is the case that ratio is worth paying for.
+    The server-side `compress` table defaults lower, since it encodes per response;
+    see `without_asgi.compression.brotli_compressor`, the shared codec behind both.
     """
-    return compressing(b"br", lambda: _BrotliCompressor(brotli.Compressor(quality=quality)))
+    return compressing(b"br", lambda: brotli_compressor(quality))
 
 
 class Decompressor(Protocol):
@@ -1767,7 +1763,7 @@ class Decompressor(Protocol):
 
 
 def _gzip_decompressor() -> Decompressor:
-    return zlib.decompressobj(wbits=_GZIP_CONTAINER)
+    return zlib.decompressobj(wbits=GZIP_CONTAINER)
 
 
 class _RawBrotliDecompressor(Protocol):
@@ -1802,12 +1798,16 @@ def _brotli_decompressor() -> Decompressor:
 
 
 # The codings decoded out of the box: gzip and zstd from the stdlib, brotli from the
-# bundled bindings. `decompress`'s default table.
-DEFAULT_DECOMPRESSORS: Mapping[bytes, Callable[[], Decompressor]] = {
-    b"br": _brotli_decompressor,
-    b"gzip": _gzip_decompressor,
-    b"zstd": zstd.ZstdDecompressor,
-}
+# bundled bindings. `decompress`'s default table, and the mirror of the server-side
+# `DEFAULT_COMPRESSORS`, a proxy for the same two reasons: nothing can mutate the table
+# every other caller starts from, and `|` extends it into a fresh `dict`.
+DEFAULT_DECOMPRESSORS: MappingProxyType[bytes, Callable[[], Decompressor]] = MappingProxyType(
+    {
+        b"br": _brotli_decompressor,
+        b"gzip": _gzip_decompressor,
+        b"zstd": zstd.ZstdDecompressor,
+    }
+)
 
 _CONTENT_CODING_HEADERS = frozenset({b"content-encoding", b"content-length"})
 
@@ -1859,7 +1859,7 @@ def decompress(
     the bundled bindings). The offer is *derived from its keys*, so what is
     advertised and what is decoded cannot disagree; register a coding this package
     does not ship by extending the table
-    (`decompress({**DEFAULT_DECOMPRESSORS, b"lzma": make_lzma})`) with any factory
+    (`decompress(DEFAULT_DECOMPRESSORS | {b"lzma": make_lzma})`) with any factory
     whose product satisfies `Decompressor`. The mapping is snapshotted, keys
     lowercased, when the middleware is built.
 

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/lifespan.py

@@ -6,7 +6,6 @@ from contextlib import asynccontextmanager
 from contextlib import suppress
 from typing import assert_never
 
-from without import cancel_futures
 from without_asgi import Asgi
 from without_asgi import ASGIApp
 from without_asgi import LifespanScope
@@ -20,6 +19,7 @@ from without_asgi import StartupFailed
 from without_asgi import encode_lifespan_event
 from without_asgi import encode_scope
 from without_asgi import parse_lifespan_reply
+from without_async import cancel_futures
 
 # Lifespan uses its own spec version, distinct from the HTTP/WebSocket scopes.
 _LIFESPAN = LifespanScope(asgi=Asgi(version="3.0", spec_version="2.0"))

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/server.py

@@ -22,9 +22,6 @@ import h2.events
 import h2.exceptions
 import h2.settings
 import h11
-from without import background_task
-from without import cancel_futures
-from without import timeout
 from without_asgi import ASGIApp
 from without_asgi import Disconnect
 from without_asgi import EarlyHint
@@ -50,6 +47,9 @@ from without_asgi import encode_websocket_inbound
 from without_asgi import encode_websocket_scope
 from without_asgi import parse_outbound
 from without_asgi import parse_websocket_outbound
+from without_async import background_task
+from without_async import cancel_futures
+from without_async import timeout
 from wsproto import ConnectionType
 from wsproto import WSConnection
 from wsproto.events import BytesMessage

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/socket_options.py

@@ -1,10 +1,16 @@
 from __future__ import annotations
 
 import socket
-from datetime import timedelta
+
+from without_async import Seconds
 
 type SocketOptions = tuple[tuple[int, int, int], ...]
 
+# Shared immutable defaults for the keepalive probe timing: a frozen count is a value, so
+# every caller can hold the same one.
+_KEEPALIVE_IDLE = Seconds(60)
+_KEEPALIVE_INTERVAL = Seconds(10)
+
 
 def apply_socket_options(sock: socket.socket | None, options: SocketOptions) -> None:
     """Apply each `(level, option, value)` triple to `sock`."""
@@ -16,8 +22,8 @@ def apply_socket_options(sock: socket.socket | None, options: SocketOptions) ->
 
 def tcp_keepalive(
     *,
-    idle: timedelta = timedelta(seconds=60),
-    interval: timedelta = timedelta(seconds=10),
+    idle: Seconds = _KEEPALIVE_IDLE,
+    interval: Seconds = _KEEPALIVE_INTERVAL,
     count: int = 6,
 ) -> SocketOptions:
     """
@@ -35,9 +41,10 @@ def tcp_keepalive(
     - `count`: unanswered probes before the connection is declared dead.
 
     So a broken idle connection is dropped roughly `idle + interval * count` after it goes
-    quiet. `idle`/`interval` MUST be a whole number of seconds, since the OS options carry
-    only integer seconds (a sub-second component is rejected here rather than silently
-    truncated); `count` is a plain probe count, not a duration.
+    quiet. `idle`/`interval` are counts of `Seconds` because the OS options carry only
+    integer seconds: a finer duration is not something either can be built from, so
+    nothing is silently truncated on the way to the socket. `count` is a plain probe
+    count, not a duration.
 
     Enabling keepalive (`SO_KEEPALIVE`) is portable, but the per-probe tuning is not
     uniformly spelled or present, so the result includes each knob only where the running
@@ -50,16 +57,13 @@ def tcp_keepalive(
       available", Windows 10+); older Windows exposes none of them, so only `SO_KEEPALIVE`
       is enabled and the probe timing stays at the system default.
     """
-    for name, duration in (("idle", idle), ("interval", interval)):
-        if duration.microseconds:
-            raise ValueError(f"{name} must be a whole number of seconds, got {duration}")
     # macOS has no TCP_KEEPIDLE and spells the idle knob TCP_KEEPALIVE; Linux and modern
     # Windows use TCP_KEEPIDLE, so prefer it and fall back to the macOS name.
     idle_option = getattr(socket, "TCP_KEEPIDLE", None) or getattr(socket, "TCP_KEEPALIVE", None)
     options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)]
     for option, value in (
-        (idle_option, int(idle.total_seconds())),
-        (getattr(socket, "TCP_KEEPINTVL", None), int(interval.total_seconds())),
+        (idle_option, idle.count),
+        (getattr(socket, "TCP_KEEPINTVL", None), interval.count),
         (getattr(socket, "TCP_KEEPCNT", None), count),
     ):
         # The skip path only fires on a platform missing a knob (e.g. older Windows),

without_http-0.0.6/src/without_http/sse.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+from collections.abc import Awaitable
+from collections.abc import Callable
+from datetime import timedelta
+from typing import assert_never
+
+from without_asgi import RawHeaders
+from without_asgi.headers import first
+from without_asgi.sse import EVENT_STREAM_MEDIA_TYPE
+from without_asgi.sse import Checkpoint
+from without_asgi.sse import ReceivedEvent
+from without_asgi.sse import Retry
+from without_asgi.sse import parse_events_with_directives
+from without_streams import close_stream
+
+from without_http.client import ClientResponse
+from without_http.client import ResponseHead
+from without_http.timeouts import HTTPTimeout
+
+# The half of Server-Sent Events that needs a transport. The format itself is two pure
+# stream transforms in `without-asgi` (`without_asgi.sse`), which is why a handler can
+# emit an event stream under uvicorn and a caller can parse one out of any
+# `Stream[bytes]`. What lives here is the loop those two cannot express on their own:
+# reconnecting a dropped stream and resuming it from the last id, which needs a client
+# exchange to reconnect *with* — the `ClientResponse` it opens each attempt against, and
+# the timeouts it treats as a stream that dropped rather than a fault.
+
+__all__ = [
+    "DEFAULT_RECONNECT",
+    "MAXIMUM_RECONNECT",
+    "MINIMUM_RECONNECT",
+    "NotAnEventStream",
+    "subscribe",
+]
+
+# How long to wait before reconnecting until a producer says otherwise with `retry:`.
+# The spec leaves the initial value to the implementation, "probably in the region of a
+# few seconds"; browsers land between two and five.
+DEFAULT_RECONNECT = timedelta(seconds=3)
+
+# The floor a producer's `retry:` is clamped to, so a hostile or broken `retry: 0`
+# cannot spin a consumer into a hot reconnect loop.
+MINIMUM_RECONNECT = timedelta(milliseconds=100)
+
+# The ceiling, for the mirrored reason: a `retry: 8640000000000` that was meant to be
+# `retry: 86400000` parks a consumer for centuries, and a subscription that is silent
+# forever with nothing raised is harder to notice than one that reconnects too often.
+# Well past any real backoff, which browsers spell in seconds.
+MAXIMUM_RECONNECT = timedelta(minutes=5)
+
+
+class NotAnEventStream(Exception):
+    """
+    The endpoint did not answer with a `200 text/event-stream` response.
+
+    Terminal, never retried: the spec fails the connection on exactly these two
+    conditions and does not reconnect afterwards, because an endpoint answering `404`
+    or `text/html` is not a stream that dropped, it is one that was never there.
+    """
+
+
+async def _sleep(duration: timedelta) -> None:
+    await asyncio.sleep(duration.total_seconds())
+
+
+def _is_event_stream(head: ResponseHead) -> bool:
+    content_type = first(head.headers, b"content-type")
+    if content_type is None:
+        return False
+    return content_type.split(b";")[0].strip().lower() == EVENT_STREAM_MEDIA_TYPE
+
+
+def subscribe(
+    attempt: Callable[[RawHeaders], Awaitable[ClientResponse]],
+    *,
+    reconnect: timedelta = DEFAULT_RECONNECT,
+    minimum_reconnect: timedelta = MINIMUM_RECONNECT,
+    maximum_reconnect: timedelta = MAXIMUM_RECONNECT,
+    max_event_size: int | None = None,
+    sleep: Callable[[timedelta], Awaitable[None]] = _sleep,
+) -> AsyncGenerator[ReceivedEvent]:
+    """
+    Consume an event stream, reconnecting and resuming when it drops.
+
+    The composition the two halves of Server-Sent Events exist to be assembled into: it
+    opens a connection, parses the response body with
+    `without_asgi.sse.parse_events_with_directives`, and when the stream ends it waits
+    and opens another one carrying `Last-Event-ID`, so the producer can resume where the
+    consumer stopped. What a caller sees is one uninterrupted stream of events across
+    however many connections it took.
+
+    ```python
+    async for event in subscribe(lambda headers: client(ClientRequest("GET", url, headers))):
+        print(event.type, event.data)
+    ```
+
+    `attempt` opens one connection: given the headers this loop wants on the request, it
+    answers with the response. A *function* rather than a `ClientRequest`, because a
+    request is not replayable. Its body is a `Stream[bytes]`, which the interface allows
+    to be iterated exactly once, and the bodies this package builds are one-shot async
+    generators, so re-sending one request value would put a full body on the wire for
+    the first attempt and an empty one on every attempt after it. Building the request
+    inside `attempt` makes that unrepresentable rather than documented, and it is what
+    lets an event stream ride a `POST` (the shape MCP's Streamable HTTP uses) instead of
+    only the bodyless `GET` a reused request survives.
+
+    The headers handed to `attempt` are `accept: text/event-stream` and, once the stream
+    has a resumption point, `last-event-id`. Pass them through as above, or `merge` them
+    with your own to decide which side wins on a name you also set.
+
+    Descending a layer is the whole point of the split, and costs one line. A caller
+    that wants exactly one connection, or its own reconnection policy, skips this and
+    parses the body directly:
+
+    ```python
+    head, body = await client(request)
+    async for event in parse_events(body):
+        ...
+    ```
+
+    ## What it retries, and what it does not
+
+    This is the only retry loop `without-http` ships, and the register's position
+    against a `retry()` middleware is why it can be: that position rejects *policy*
+    the library would have to invent (how many attempts, which statuses, what backoff),
+    and here there is none to invent. The backoff arrives on the wire as `retry:`, the
+    resumption token arrives as `id:`, and the terminal condition is written into the
+    protocol. What the settings below decide is how far to trust the peer that supplies
+    them.
+
+    - A **non-`200` status or a content type other than `text/event-stream`** raises
+      `NotAnEventStream` and never reconnects, per the spec's terminal failure.
+    - The **first connection's errors propagate**. A caller that cannot reach the
+      endpoint at all learns so immediately instead of watching a silent loop.
+    - Once a stream has been established, a **connection error or timeout, on the
+      stream or on any later attempt, reconnects** after the current wait. A stream
+      that a proxy reaps every 60 seconds is the ordinary case, not the exceptional
+      one, which is why the protocol has a resumption token at all.
+
+    `reconnect` is the wait until the producer names one with `retry:`, after which its
+    value is used, clamped to between `minimum_reconnect` (100ms) and
+    `maximum_reconnect` (five minutes). Both ends guard the same thing, a `retry:` that
+    is hostile or merely wrong: at zero it would spin a consumer into a hot reconnect
+    loop, and a few orders of magnitude too large it would park one on a subscription
+    that goes silent forever with nothing raised to notice. Widen either end for a
+    producer you trust to name its own backoff, or narrow them to hold a peer to a
+    window you chose. `max_event_size` is passed through to the parser. `sleep` is the
+    delay, injected so a test drives the loop without waiting (and so a caller can add
+    jitter).
+
+    Reflecting a producer's value into a request header is safe here because the parser
+    only ever hands on an id a header can carry unchanged: a carriage return or line
+    feed is what ended the field, and an `id:` a field value could not spell, or would
+    silently alter, is ignored rather than resumed from.
+
+    An `AsyncGenerator` rather than a bare `AsyncIterator`, because this holds a live
+    connection and a caller that stops early should be able to say so: `aclose()`
+    releases it there and then, rather than at whenever the collector gets to it.
+    """
+    # An ordinary function wrapping the generator, so a contradictory window is refused
+    # where the caller wrote it. The same guards inside the generator body would not run
+    # until the first `anext`, which is after the first request is on the wire and may be
+    # arbitrarily long after the mistake was made.
+    if not timedelta() <= minimum_reconnect <= maximum_reconnect:
+        raise ValueError(
+            f"the reconnection window runs from zero upwards, not from {minimum_reconnect!r} to {maximum_reconnect!r}"
+        )
+    if reconnect < timedelta():
+        raise ValueError(f"an initial reconnection wait cannot be negative: {reconnect!r}")
+    return _subscribed(
+        attempt,
+        reconnect=reconnect,
+        minimum_reconnect=minimum_reconnect,
+        maximum_reconnect=maximum_reconnect,
+        max_event_size=max_event_size,
+        sleep=sleep,
+    )
+
+
+async def _subscribed(
+    attempt: Callable[[RawHeaders], Awaitable[ClientResponse]],
+    *,
+    reconnect: timedelta,
+    minimum_reconnect: timedelta,
+    maximum_reconnect: timedelta,
+    max_event_size: int | None,
+    sleep: Callable[[timedelta], Awaitable[None]],
+) -> AsyncGenerator[ReceivedEvent]:
+    last_id = ""
+    wait = reconnect
+    established = False
+    # What every attempt offers. `last-event-id` joins it once the stream has a
+    # resumption point, and the caller decides how these meet the request's own headers.
+    offered: RawHeaders = ((b"accept", EVENT_STREAM_MEDIA_TYPE),)
+
+    while True:
+        headers = (*offered, (b"last-event-id", last_id.encode())) if last_id else offered
+        try:
+            head, body = await attempt(headers)
+        except OSError, HTTPTimeout:
+            if not established:
+                raise
+            await sleep(wait)
+            continue
+
+        if head.status != 200 or not _is_event_stream(head):
+            await body.aclose()
+            raise NotAnEventStream(
+                f"expected a 200 text/event-stream response, got {head.status} "
+                f"{(first(head.headers, b'content-type') or b'with no content-type').decode('latin-1')}"
+            )
+        established = True
+
+        # Each connection parses from the id it resumed with, so an event carrying no
+        # `id:` of its own reports that rather than nothing: the spec seeds a reconnected
+        # parser's last event ID buffer for exactly this reason, and a parser starting
+        # from empty would erase the resumption point the next reconnect needs.
+        items = parse_events_with_directives(body, last_event_id=last_id, max_event_size=max_event_size)
+        try:
+            async for item in items:
+                match item:
+                    case ReceivedEvent():
+                        last_id = item.id
+                        yield item
+                    case Retry(after):
+                        wait = min(max(after.duration, minimum_reconnect), maximum_reconnect)
+                    case Checkpoint(moved_to):
+                        # A frame that moved the resumption point without delivering an
+                        # event. Missing these resumes from before whatever the producer
+                        # skipped, which is the whole reason it sent one.
+                        last_id = moved_to
+                    case _ as unreachable:
+                        assert_never(unreachable)
+        except OSError, HTTPTimeout:
+            # A dropped stream is the ordinary end of a long-lived connection, not a
+            # fault to surface: that is what the resumption token is for.
+            pass
+        finally:
+            # The parser as well as the body, because a caller closing the subscription
+            # stops this generator at the `yield` above and leaves both of them open.
+            await close_stream(items)
+            await body.aclose()
+
+        await sleep(wait)

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/testing.py

@@ -16,7 +16,6 @@ from typing import assert_never
 from urllib.parse import unquote
 from urllib.parse import urlsplit
 
-from without import cancel_futures
 from without_asgi import Asgi
 from without_asgi import ASGIApp
 from without_asgi import Disconnect
@@ -35,6 +34,7 @@ from without_asgi import encode_inbound
 from without_asgi import parse_outbound
 from without_asgi.outbound import ResponseBody as OutboundBody
 from without_asgi.outbound import ResponseTrailers as OutboundTrailers
+from without_async import cancel_futures
 
 from without_http.client import _NO_TIMEOUT
 from without_http.client import Client

{without_http-0.0.4 → without_http-0.0.6}/src/without_http/timeouts.py

@@ -6,7 +6,7 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import timedelta
 
-from without import timeout
+from without_async import timeout
 
 
 @dataclass(frozen=True, slots=True)