workers-runtime-sdk 1.7.0__tar.gz → 1.8.0__tar.gz

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 <!-- version list -->
 
+## v1.8.0 (2026-08-28)
+
+### Bug Fixes
+
+- Defer ASGI lifespan shutdown until request completion
+  ([`3249184`](https://github.com/cloudflare/workers-py/commit/324918442748a0b87affc6128315ceb190e1b368))
+
+- Make wsgi streaming response handlers async
+  ([#191](https://github.com/cloudflare/workers-py/pull/191),
+  [`12168ae`](https://github.com/cloudflare/workers-py/commit/12168aef7599067a910a518f1ce7860a00ae9a58))
+
+- **runtime-sdk**: Close the WebSocket transport when the app task ends
+  ([#166](https://github.com/cloudflare/workers-py/pull/166),
+  [`e67e7e7`](https://github.com/cloudflare/workers-py/commit/e67e7e78af7fa6976f1f9966508b9869a6840ce5))
+
+### Features
+
+- Add wsgi.entrypoint like asgi.entrypoint
+  ([#232](https://github.com/cloudflare/workers-py/pull/232),
+  [`e044561`](https://github.com/cloudflare/workers-py/commit/e04456174b3f5bc9df8b3f8293ced6d08aaffc0f))
+
+
 ## v1.7.0 (2026-08-24)
 
 ### Bug Fixes

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.7.0
+Version: 1.8.0
 Summary: Python SDK for Cloudflare Workers
 Project-URL: Homepage, https://github.com/cloudflare/workers-py
 Project-URL: Bug Tracker, https://github.com/cloudflare/workers-py/issues

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.7.0"
+version = "1.8.0"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/src/workers/asgi.py

@@ -16,7 +16,7 @@ logger = logging.getLogger("asgi")
 background_tasks = set()
 
 
-def run_in_background(coro: Awaitable[Any]) -> None:
+def run_in_background(coro: Awaitable[Any]) -> Future:
     fut = ensure_future(coro)
     background_tasks.add(fut)
 
@@ -27,6 +27,7 @@ def run_in_background(coro: Awaitable[Any]) -> None:
             logger.error("Unhandled exception in background task", exc_info=exc)
 
     fut.add_done_callback(_on_done)
+    return fut
 
 
 async def close_stream_quietly(writer):
@@ -185,7 +186,7 @@ async def process_request(  # noqa: PLR0913
     # TODO(later): remove this parameter after unvendoring Python SDK from workerd
     ctx: Context | None,
     state: dict[str, Any] | None = None,
-) -> js.Response:
+) -> tuple[js.Response, Future[None]]:
     from js import Response, TransformStream
     from pyodide.ffi import create_proxy
 
@@ -304,17 +305,22 @@ async def process_request(  # noqa: PLR0913
                     # runtime is waiting on through wait_until.
                     run_in_background(close_stream_quietly(writer))
 
-    # Create task to run the application in the background
-    app_task = create_proxy(create_task(run_app()))
-
-    from workers import wait_until
-
-    wait_until(app_task)
+    request_task = create_task(run_app())
 
     try:
-        return await result
-    finally:
-        app_task.destroy()
+        response = await result
+    except Exception:
+        # The request task handles application exceptions and should be allowed
+        # to finish before its error is propagated to fetch().
+        await request_task
+        raise
+
+    # Buffered responses do not depend on a consumer, so request cleanup can
+    # finish before returning. Streaming responses must run alongside the
+    # consumer because writes can be subject to backpressure.
+    if writer is None:
+        await request_task
+    return response, request_task
 
 
 async def process_websocket(
@@ -359,7 +365,10 @@ async def process_websocket(
     server.onclose = onclose
     server.onmessage = onmessage
 
+    app_closed = False
+
     async def ws_send(got):
+        nonlocal app_closed
         if got["type"] == "websocket.accept":
             # The Workers WebSocketPair is accepted before the upgrade response
             # is returned, so there is no deferred accept operation here.
@@ -376,6 +385,7 @@ async def process_websocket(
                 server.send(s)
             return
         if got["type"] == "websocket.close":
+            app_closed = True
             server.close(got.get("code", 1000), got.get("reason", ""))
             return
         logger.warning(" == Not implemented %s", got["type"])
@@ -384,13 +394,34 @@ async def process_websocket(
         received = await queue.get()
         return received
 
-    run_in_background(
+    from pyodide.ffi import create_proxy
+
+    from workers import wait_until
+
+    task = run_in_background(
         app(
             request_to_scope(req, env if env is not None else {}, ws=True),
             ws_receive,
             ws_send,
         )
     )
+    # wait_until is JS's waitUntil, so the task crosses the boundary as a proxy,
+    # destroyed once it settles rather than left to leak.
+    task_proxy = create_proxy(task)
+
+    def _close_transport(finished):
+        if not app_closed:
+            # The app ended without closing, so a half-open connection would
+            # leave the client hanging instead of reconnecting.
+            failed = not finished.cancelled() and finished.exception() is not None
+            try:
+                server.close(1011 if failed else 1000, "")
+            except Exception:
+                pass  # the peer may already have closed the socket
+        task_proxy.destroy()
+
+    task.add_done_callback(_close_transport)
+    wait_until(task_proxy)
 
     return Response.new(None, status=101, webSocket=client)
 
@@ -401,11 +432,25 @@ async def fetch(
     logger.debug("ASGI request: %s %s", req.method, req.url)
     shutdown, state = await start_application(app)
     try:
-        result = await process_request(app, req, env, ctx, state=state)
+        result, request_task = await process_request(app, req, env, ctx, state=state)
     except Exception:
         logger.exception("ASGI request failed")
+        await shutdown()
         raise
-    await shutdown()
+
+    if request_task.done():
+        await shutdown()
+    else:
+        from workers import wait_until  # noqa: PLC0415
+
+        async def finalize_request():
+            try:
+                await request_task
+            finally:
+                await shutdown()
+
+        wait_until(run_in_background(finalize_request()))
+
     return result
 
 

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/src/workers/wsgi.py

@@ -7,7 +7,7 @@ from urllib.parse import unquote, urlsplit
 
 import js
 
-from workers import Context, Request
+from workers import Context, Request, WorkerEntrypoint
 
 logger = logging.getLogger("wsgi")
 NULL_BODY_STATUSES = frozenset({101, 103, 204, 205, 304})
@@ -262,8 +262,9 @@ def _make_streaming_response(
             for proxy in proxies:
                 proxy.destroy()
 
+    # Make proxies async so that it is possible to stack switch inside them.
     @create_proxy
-    def pull(controller: Any) -> None:
+    async def pull(controller: Any) -> None:
         try:
             chunk = next(chunks, _END)
         except Exception as exc:  # noqa: BLE001 - forward app errors to the stream
@@ -278,7 +279,7 @@ def _make_streaming_response(
         controller.enqueue(_to_js_uint8array(chunk))
 
     @create_proxy
-    def cancel(_reason: Any = None) -> None:
+    async def cancel(_reason: Any = None) -> None:
         cleanup()
 
     proxies = [pull, cancel]
@@ -378,3 +379,13 @@ async def fetch(
     except Exception:
         logger.exception("WSGI request failed")
         raise
+
+
+def entrypoint(app: Any) -> type[WorkerEntrypoint]:
+    """Create the default Worker entrypoint for a WSGI application."""
+
+    class Default(WorkerEntrypoint):
+        async def fetch(self, request):
+            return await fetch(app, request, self.env)
+
+    return Default

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/tests/web-frameworks-test/fastapi-tests/src/_client.py

@@ -1,5 +1,8 @@
 import json as _json
 
+import js
+from pyodide.ffi import create_proxy, to_js
+
 import asgi
 from workers import Request
 
@@ -63,6 +66,35 @@ def build_multipart_bytes(files, boundary="----WebTestBoundary"):
     return bytes(body), f"multipart/form-data; boundary={boundary}"
 
 
+async def fetch_chunks(app, path, chunks, env=None, method="POST", headers=None):
+    """Send a request body as a JS ReadableStream with explicit chunk boundaries."""
+    from js import Object
+
+    chunks = list(chunks)
+
+    def start(controller):
+        for chunk in chunks:
+            controller.enqueue(to_js(chunk))
+        controller.close()
+
+    start_proxy = create_proxy(start)
+    try:
+        stream = js.ReadableStream.new(
+            to_js({"start": start_proxy}, dict_converter=Object.fromEntries)
+        )
+        hdrs = dict(headers or {})
+        hdrs.setdefault("Content-Length", str(sum(len(chunk) for chunk in chunks)))
+        request = Request(
+            f"{BASE_URL}{path}",
+            method=method,
+            headers=hdrs,
+            body=stream,
+        )
+        return await asgi.fetch(app, request, env or {})
+    finally:
+        start_proxy.destroy()
+
+
 def build_multipart(files, boundary="----WebTestBoundary"):
     """Build a multipart/form-data body from a list of (name, filename, content) tuples."""
     lines = []

workers_runtime_sdk-1.8.0/tests/web-frameworks-test/fastapi-tests/src/test_platform_boundaries.py

@@ -0,0 +1,99 @@
+"""Tests across the FastAPI, Pyodide, and Workers runtime boundaries."""
+
+import asyncio
+import gzip
+import hashlib
+import json
+
+import pytest
+from _client import fetch, fetch_chunks, read_json
+from worker import reset_platform_concurrency
+
+
+@pytest.mark.asyncio
+async def test_chunked_js_stream_preserves_utf8_and_boundaries(fastapi_app):
+    """A JS ReadableStream survives the JS-to-Python ASGI receive bridge."""
+    value = {
+        "message": "worker \u0063\u0061\u0066\u00e9 \U0001f680",
+        "items": [1, 2, 3],
+    }
+    body = json.dumps(value, ensure_ascii=False).encode()
+    emoji = "\U0001f680".encode()
+    emoji_start = body.index(emoji)
+    cuts = [7, emoji_start + 1, emoji_start + 3, len(body) - 2]
+    chunks = []
+    start = 0
+    for end in cuts + [len(body)]:
+        chunks.append(body[start:end])
+        start = end
+
+    resp = await fetch_chunks(
+        fastapi_app,
+        "/platform/chunked-json",
+        chunks,
+        headers={"Content-Type": "application/json"},
+    )
+    assert resp.status == 200
+    data = await read_json(resp)
+    assert data["chunk_sizes"] == [len(chunk) for chunk in chunks]
+    assert data["sha256"] == hashlib.sha256(body).hexdigest()
+    assert data["data"] == value
+
+
+@pytest.mark.asyncio
+async def test_concurrent_requests_keep_bindings_and_data_isolated(fastapi_app):
+    """Interleaved requests retain their own env, headers, and bodies."""
+    reset_platform_concurrency()
+
+    async def request(marker):
+        resp = await fetch(
+            fastapi_app,
+            "/platform/concurrent-env",
+            env={"marker": marker},
+            method="POST",
+            headers={"X-Request-Marker": marker},
+            body=f"body-{marker}",
+        )
+        assert resp.status == 200
+        return await read_json(resp)
+
+    first, second = await asyncio.wait_for(
+        asyncio.gather(request("first"), request("second")), timeout=5
+    )
+    assert first == {
+        "binding": "first",
+        "header": "first",
+        "body": "body-first",
+    }
+    assert second == {
+        "binding": "second",
+        "header": "second",
+        "body": "body-second",
+    }
+
+
+@pytest.mark.asyncio
+async def test_multiple_set_cookie_headers_survive_fastapi(fastapi_app):
+    """FastAPI's separate Set-Cookie headers remain distinct through JS Headers."""
+    resp = await fetch(fastapi_app, "/platform/multiple-cookies")
+    assert resp.status == 200
+    cookies = list(resp.headers.getSetCookie())
+    assert len(cookies) == 3
+    assert cookies[0].startswith("first=1;")
+    assert cookies[1].startswith("second=two;")
+    assert cookies[2].startswith("dated=3;")
+    assert "Wed, 21 Oct 2037 07:28:00 GMT" in cookies[2]
+
+
+@pytest.mark.asyncio
+async def test_gzip_middleware_preserves_binary_body(fastapi_app):
+    """GZipMiddleware compresses binary data streamed through a JS Response."""
+    expected = bytes(range(256)) * 32
+    resp = await fetch(
+        fastapi_app,
+        "/platform/gzip-binary",
+        headers={"Accept-Encoding": "gzip"},
+    )
+    assert resp.status == 200
+    assert resp.headers.get("content-encoding") == "gzip"
+    assert gzip.decompress((await resp.bytes()).to_bytes()) == expected

workers_runtime_sdk-1.8.0/tests/web-frameworks-test/fastapi-tests/src/test_platform_lifecycle.py

@@ -0,0 +1,46 @@
+"""FastAPI lifecycle tests targeting the Workers ASGI streaming boundary."""
+
+import asyncio
+
+import pytest
+from _client import fetch, get_json
+from worker import (
+    _platform_events,
+    _platform_shutdown_complete,
+    reset_platform_events,
+)
+
+
+@pytest.mark.asyncio
+async def test_lifespan_state_reaches_request(fastapi_app):
+    """State yielded by FastAPI's lifespan context is copied to HTTP scopes."""
+    resp, data = await get_json(fastapi_app, "/platform/lifespan-state")
+    assert resp.status == 200
+    assert data == {"available": True, "closed": False}
+
+
+@pytest.mark.asyncio
+async def test_stream_finishes_before_cleanup_and_shutdown(fastapi_app):
+    """Streaming, background work, and dependency cleanup precede shutdown."""
+    reset_platform_events()
+
+    resp = await asyncio.wait_for(
+        fetch(fastapi_app, "/platform/lifecycle-stream"), timeout=5
+    )
+    assert resp.status == 200
+    assert await asyncio.wait_for(resp.text(), timeout=5) == (
+        "chunk-0\nchunk-1\nchunk-2\n"
+    )
+    await asyncio.wait_for(_platform_shutdown_complete.wait(), timeout=5)
+
+    assert _platform_events == [
+        "lifespan-startup",
+        "dependency-open",
+        "handler",
+        "chunk-0",
+        "chunk-1",
+        "chunk-2",
+        "background-task",
+        "dependency-close",
+        "lifespan-shutdown",
+    ]

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -2,6 +2,7 @@ import asyncio
 import enum
 import hashlib
 import importlib.util
+import json
 from contextlib import asynccontextmanager
 from pathlib import Path
 
@@ -32,6 +33,7 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 from pyodide.webloop import WebLoop
 from starlette.background import BackgroundTask
+from starlette.middleware.gzip import GZipMiddleware
 
 import asgi
 
@@ -51,16 +53,40 @@ class PlatformResource:
         self.closed = False
 
 
+_platform_events: list[str] = []
+_platform_shutdown_complete = asyncio.Event()
+
+
+def reset_platform_events():
+    _platform_events.clear()
+    _platform_shutdown_complete.clear()
+
+
 @asynccontextmanager
 async def _platform_lifespan(_app):
     resource = PlatformResource()
+    _platform_events.append("lifespan-startup")
     try:
         yield {"platform_resource": resource}
     finally:
         resource.closed = True
+        _platform_events.append("lifespan-shutdown")
+        _platform_shutdown_complete.set()
 
 
 app = FastAPI(lifespan=_platform_lifespan)
+app.add_middleware(GZipMiddleware, minimum_size=1024)
+
+_platform_concurrency_ready = asyncio.Event()
+_platform_concurrency_count = 0
+
+
+def reset_platform_concurrency():
+    global _platform_concurrency_count
+
+    _platform_concurrency_count = 0
+    _platform_concurrency_ready.clear()
+
 
 # --------------------------------------------------------------------------- #
 # Shared mutable state used to verify side-effects (e.g. background tasks).
@@ -463,6 +489,91 @@ async def platform_upload_spooled(file: UploadFile = File(...)):  # noqa: B008
     }
 
 
+@app.post("/platform/chunked-json")
+async def platform_chunked_json(request: Request):
+    chunks = [chunk async for chunk in request.stream() if chunk]
+    body = b"".join(chunks)
+    return {
+        "chunk_sizes": [len(chunk) for chunk in chunks],
+        "sha256": hashlib.sha256(body).hexdigest(),
+        "data": json.loads(body),
+    }
+
+
+@app.post("/platform/concurrent-env")
+async def platform_concurrent_env(
+    request: Request,
+    bindings=asgi.env,  # noqa: B008
+):
+    global _platform_concurrency_count
+
+    _platform_concurrency_count += 1
+    if _platform_concurrency_count == 2:
+        _platform_concurrency_ready.set()
+    await asyncio.wait_for(_platform_concurrency_ready.wait(), timeout=5)
+    body = await request.body()
+    return {
+        "binding": bindings["marker"],
+        "header": request.headers["x-request-marker"],
+        "body": body.decode(),
+    }
+
+
+@app.get("/platform/multiple-cookies")
+async def platform_multiple_cookies():
+    response = JSONResponse({"ok": True})
+    response.set_cookie("first", "1")
+    response.set_cookie("second", "two")
+    response.set_cookie("dated", "3", expires="Wed, 21 Oct 2037 07:28:00 GMT")
+    return response
+
+
+@app.get("/platform/gzip-binary")
+async def platform_gzip_binary():
+    return FastAPIResponse(
+        content=(bytes(range(256)) * 32),
+        media_type="application/octet-stream",
+    )
+
+
+def _stream_resource():
+    resource = PlatformResource()
+    _platform_events.append("dependency-open")
+    try:
+        yield resource
+    finally:
+        resource.closed = True
+        _platform_events.append("dependency-close")
+
+
+async def _platform_background_task():
+    await asyncio.sleep(0)
+    _platform_events.append("background-task")
+
+
+@app.get("/platform/lifecycle-stream")
+async def platform_lifecycle_stream(
+    request: Request,
+    resource: PlatformResource = Depends(_stream_resource),  # noqa: B008
+):
+    lifespan_resource = request.state.platform_resource
+    _platform_events.append("handler")
+
+    async def chunks():
+        for index in range(3):
+            assert not resource.closed
+            assert not lifespan_resource.closed
+            _platform_events.append(f"chunk-{index}")
+            yield f"chunk-{index}\n"
+            await asyncio.sleep(0)
+
+    return StreamingResponse(
+        chunks(),
+        media_type="text/plain",
+        background=BackgroundTask(_platform_background_task),
+    )
+
+
 @app.get("/native-file")
 async def native_file():
     """Serve a single bundled file with FastAPI's native FileResponse."""

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -159,3 +159,11 @@ async def test_environment_reaches_websocket_scope():
         ws.send("env")
         event = await asyncio.wait_for(message, TIMEOUT_S)
         assert event.data == "worker-environment"
+
+
+@pytest.mark.asyncio
+async def test_app_crash_closes_the_transport():
+    async with _ws_session("/ws-crash") as ws:
+        close = _listen(ws, "close")
+        evt = await asyncio.wait_for(close, TIMEOUT_S)
+        assert evt.code == 1011

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/tests/workerd-test/asgi-ws-disconnect/worker.py

@@ -133,11 +133,25 @@ class WSEnvApp:
         await send({"type": "websocket.send", "text": scope["env"]["marker"]})
 
 
+class WSCrashApp:
+    """Accepts, then raises: the server must close the transport (1011)."""
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            await _drain_lifespan(receive, send)
+            return
+        message = await receive()
+        assert message["type"] == "websocket.connect"
+        await send({"type": "websocket.accept"})
+        raise RuntimeError("websocket app crashed")
+
+
 ws_app = WSWatchApp()
 echo_app = WSEchoApp()
 empty_frame_app = WSEmptyFrameApp()
 close_app = WSCloseApp()
 env_app = WSEnvApp()
+crash_app = WSCrashApp()
 
 
 class Default(WorkerEntrypoint):
@@ -152,6 +166,7 @@ class Default(WorkerEntrypoint):
                 "/ws-close": close_app,
                 "/ws-echo": echo_app,
                 "/ws-empty": empty_frame_app,
+                "/ws-crash": crash_app,
             }.get(path, ws_app)
             return await asgi.websocket(app, request)
         import json

{workers_runtime_sdk-1.7.0 → workers_runtime_sdk-1.8.0}/tests/workerd-test/wsgi/tests/test_wsgi.py

@@ -8,9 +8,24 @@ from worker import (
     STREAMING_NUM_CHUNKS,
     crash_app,
     example_hdr,
+    header_echo_app,
 )
 
-from workers import Request, env, wsgi
+from workers import Request, WorkerEntrypoint, env, wsgi
+
+
+@pytest.mark.asyncio
+async def test_generated_entrypoint_serves_wsgi_app():
+    default = wsgi.entrypoint(header_echo_app)
+    assert default.__name__ == "Default"
+    assert issubclass(default, WorkerEntrypoint)
+
+    entrypoint = object.__new__(default)
+    entrypoint.env = {}
+    response = await entrypoint.fetch(js.Request.new("http://example.com/"))
+
+    assert response.status == 200
+    assert await response.text() == "Hello, World"
 
 
 @pytest.mark.asyncio
@@ -62,9 +77,10 @@ async def test_cookies():
     assert "b=2" in cookies
 
 
+@pytest.mark.parametrize("endpoint", ("stream", "stream-stack-switch"))
 @pytest.mark.asyncio
-async def test_streaming():
-    response = await env.SELF.fetch("http://example.com/stream")
+async def test_streaming(endpoint):
+    response = await env.SELF.fetch("http://example.com/" + endpoint)
     assert response.status == 200
     assert response.headers.get("content-type") == "application/octet-stream"