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

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

@@ -2,6 +2,41 @@
 
 <!-- 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
+
+- Fixes Request body being released too early
+  ([`84a20ac`](https://github.com/cloudflare/workers-py/commit/84a20acbfa28ea82fb69b2c279a56d9e25fd9639))
+
+### Features
+
+- Asgi.entrypoint syntax sugar for nicer asgi apps
+  ([`5399270`](https://github.com/cloudflare/workers-py/commit/539927085a79e2d88a287cc70ccfa433ec257e1d))
+
+
 ## v1.6.15 (2026-08-21)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.6.15
+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.6.15 → workers_runtime_sdk-1.8.0}/pyproject.toml

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

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

@@ -7,7 +7,7 @@ from urllib.parse import unquote
 
 import js
 
-from workers import Context, Request
+from workers import Context, Request, WorkerEntrypoint
 from workers.utils import _to_js_headers
 
 ASGI = {"spec_version": "2.0", "version": "3.0"}
@@ -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
 
 
@@ -415,6 +460,18 @@ async def websocket(
     return await process_websocket(app, req, env)
 
 
+def entrypoint(app: Any) -> type[WorkerEntrypoint]:
+    """Create the default Worker entrypoint for an ASGI application."""
+
+    class Default(WorkerEntrypoint):
+        async def fetch(self, request):
+            if (request.headers.get("upgrade") or "").lower() == "websocket":
+                return await websocket(app, request, self.env)
+            return await fetch(app, request, self.env, self.ctx)
+
+    return Default
+
+
 def __getattr__(name):
     if name == "env":
         from fastapi import Depends, Request

{workers_runtime_sdk-1.6.15 → workers_runtime_sdk-1.8.0}/src/workers/request.py

@@ -9,6 +9,7 @@ from .blob import Blob
 from .formdata import FormData
 from .types import FetchKwargs
 from .utils import (
+    _get_js_body,
     _is_js_instance,
     _js_headers_to_http_message,
     _jsnull_to_none,
@@ -36,9 +37,14 @@ class Request:
 
         if "headers" in other_options:
             other_options["headers"] = _to_js_headers(other_options["headers"])
-        self._js_request = js.Request.new(
-            input._js_request if isinstance(input, Request) else input, **other_options
-        )
+        body = other_options.pop("body", None)
+        with _get_js_body(body) as js_body:
+            if body is not None:
+                other_options["body"] = js_body
+            self._js_request = js.Request.new(
+                input._js_request if isinstance(input, Request) else input,
+                **other_options,
+            )
 
     def __repr__(self):
         return (

{workers_runtime_sdk-1.6.15 → workers_runtime_sdk-1.8.0}/src/workers/response.py

@@ -1,17 +1,17 @@
 import json
-from contextlib import contextmanager
 from http import HTTPStatus
 from typing import Any, Never
 
 import js
 import pyodide.http
-from pyodide.ffi import JsException, JsProxy, create_proxy
+from pyodide.ffi import JsException, JsProxy
 
 from .blob import Blob
 from .formdata import FormData
 from .types import Body, Headers
 from .utils import (
     RESPONSE_ACCEPTED_TYPES,
+    _get_js_body,
     _get_js_constructor_name,
     _is_js_instance,
     _js_headers_to_http_message,
@@ -21,23 +21,6 @@ from .utils import (
 )
 
 
-@contextmanager
-def _get_js_body(body):
-    if isinstance(body, bytes):
-        proxy_bytes = create_proxy(body)
-        proxy_buffer = proxy_bytes.getBuffer()
-        try:
-            yield proxy_buffer.data
-            return
-        finally:
-            proxy_buffer.release()
-            proxy_bytes.destroy()
-    if isinstance(body, FormData):
-        yield body.js_object
-        return
-    yield body
-
-
 class FetchResponse(pyodide.http.FetchResponse):
     # TODO: Consider upstreaming the `body` attribute
     # TODO: Behind a compat flag make this return a native stream (StreamReader?), or perhaps

{workers_runtime_sdk-1.6.15 → workers_runtime_sdk-1.8.0}/src/workers/utils.py

@@ -6,6 +6,7 @@ import _pyodide_entrypoint_helper
 import js
 from pyodide.ffi import (
     JsException,
+    create_proxy,
     destroy_proxies,
     to_js,
 )
@@ -51,6 +52,25 @@ _JS_PASSTHROUGH_TYPES = RESPONSE_ACCEPTED_TYPES | {
 }
 
 
+@contextmanager
+def _get_js_body(body):
+    from .formdata import FormData
+
+    if isinstance(body, bytes):
+        proxy_bytes = create_proxy(body)
+        proxy_buffer = proxy_bytes.getBuffer()
+        try:
+            yield proxy_buffer.data
+            return
+        finally:
+            proxy_buffer.release()
+            proxy_bytes.destroy()
+    if isinstance(body, FormData):
+        yield body.js_object
+        return
+    yield body
+
+
 def _jsnull_to_none(x):
     if x is jsnull:
         return None

{workers_runtime_sdk-1.6.15 → 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.6.15 → 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
 
@@ -46,6 +49,52 @@ async def post_json(app, path, data, **kwargs):
     )
 
 
+def build_multipart_bytes(files, boundary="----WebTestBoundary"):
+    """Build a binary-safe multipart body from (name, filename, bytes) tuples."""
+    body = bytearray()
+    for name, filename, content in files:
+        if isinstance(content, str):
+            content = content.encode()
+        body.extend(f"--{boundary}\r\n".encode())
+        body.extend(
+            f'Content-Disposition: form-data; name="{name}"; filename="{filename}"\r\n'.encode()
+        )
+        body.extend(b"Content-Type: application/octet-stream\r\n\r\n")
+        body.extend(content)
+        body.extend(b"\r\n")
+    body.extend(f"--{boundary}--\r\n".encode())
+    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_io.py

@@ -0,0 +1,31 @@
+"""Binary I/O tests across FastAPI, Pyodide, and workerd."""
+
+import hashlib
+
+import pytest
+from _client import build_multipart_bytes, fetch, read_json
+
+
+@pytest.mark.asyncio
+async def test_upload_spills_binary_file_to_virtual_disk(fastapi_app):
+    """UploadFile remains correct after SpooledTemporaryFile rolls to disk."""
+    payload = bytes(range(256)) * 5120  # 1.25 MiB, above Starlette's 1 MiB limit.
+    body, content_type = build_multipart_bytes(
+        [("file", "binary.dat", payload)], boundary="----SpoolBoundary"
+    )
+
+    resp = await fetch(
+        fastapi_app,
+        "/platform/upload-spooled",
+        method="POST",
+        headers={"Content-Type": content_type},
+        body=body,
+    )
+    assert resp.status == 200
+    data = await read_json(resp)
+    assert data == {
+        "size": len(payload),
+        "sha256": hashlib.sha256(payload).hexdigest(),
+        "reread_matches": True,
+        "rolled_to_disk": True,
+    }

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.6.15 → workers_runtime_sdk-1.8.0}/tests/web-frameworks-test/fastapi-tests/src/test_routing.py

@@ -20,6 +20,15 @@ These are relevant for Pyodide/Workers because:
 
 import pytest
 from _client import fetch, get_json, read_json
+from worker import Default
+
+from workers import WorkerEntrypoint
+
+
+def test_asgi_entrypoint_factory():
+    assert Default.__name__ == "Default"
+    assert issubclass(Default, WorkerEntrypoint)
+
 
 # -- Path parameters ---------------------------------------------------------
 

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

@@ -0,0 +1,39 @@
+import asyncio
+
+import pytest
+from pyodide.ffi import create_proxy
+from worker import Default
+
+from workers import Request
+
+TIMEOUT_S = 5
+_proxies = []
+
+
+@pytest.mark.asyncio
+async def test_generated_entrypoint_serves_fastapi_websocket():
+    entrypoint = object.__new__(Default)
+    entrypoint.env = {}
+    request = Request(
+        "http://testserver/websocket/echo", headers={"Upgrade": "websocket"}
+    )
+
+    response = await entrypoint.fetch(request)
+    assert response.status == 101
+
+    websocket = response.webSocket
+    websocket.accept()
+    message = asyncio.get_event_loop().create_future()
+
+    def onmessage(event):
+        if not message.done():
+            message.set_result(event.data)
+
+    proxy = create_proxy(onmessage)
+    _proxies.append(proxy)
+    websocket.addEventListener("message", proxy)
+    try:
+        websocket.send("hello")
+        assert await asyncio.wait_for(message, TIMEOUT_S) == "echo:hello"
+    finally:
+        websocket.close()