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

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

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## 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
+
+- Handle ASGI WebSocket close events and environment propagation
+  ([`47cc488`](https://github.com/cloudflare/workers-py/commit/47cc488e2bad1c9f3030a16d73301b80fca90f5c))
+
+
 ## v1.6.14 (2026-08-19)
 
 ### Bug Fixes

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

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

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

{workers_runtime_sdk-1.6.14 → workers_runtime_sdk-1.7.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"}
@@ -317,7 +317,9 @@ async def process_request(  # noqa: PLR0913
         app_task.destroy()
 
 
-async def process_websocket(app: Any, req: "Request | js.Request") -> js.Response:
+async def process_websocket(
+    app: Any, req: "Request | js.Request", env: Any = None
+) -> js.Response:
     from js import Response, WebSocketPair
 
     client, server = WebSocketPair.new().object_values()
@@ -358,6 +360,10 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
     server.onmessage = onmessage
 
     async def ws_send(got):
+        if got["type"] == "websocket.accept":
+            # The Workers WebSocketPair is accepted before the upgrade response
+            # is returned, so there is no deferred accept operation here.
+            return
         if got["type"] == "websocket.send":
             b = got.get("bytes", None)
             s = got.get("text", None)
@@ -368,16 +374,23 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
                     server.send(jsbytes)
             if s is not None:
                 server.send(s)
-
-        else:
-            logger.warning(" == Not implemented %s", got["type"])
+            return
+        if got["type"] == "websocket.close":
+            server.close(got.get("code", 1000), got.get("reason", ""))
+            return
+        logger.warning(" == Not implemented %s", got["type"])
 
     async def ws_receive():
         received = await queue.get()
         return received
 
-    env = {}
-    run_in_background(app(request_to_scope(req, env, ws=True), ws_receive, ws_send))
+    run_in_background(
+        app(
+            request_to_scope(req, env if env is not None else {}, ws=True),
+            ws_receive,
+            ws_send,
+        )
+    )
 
     return Response.new(None, status=101, webSocket=client)
 
@@ -396,8 +409,22 @@ async def fetch(
     return result
 
 
-async def websocket(app: Any, req: "Request | js.Request") -> js.Response:
-    return await process_websocket(app, req)
+async def websocket(
+    app: Any, req: "Request | js.Request", env: Any = None
+) -> js.Response:
+    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):

{workers_runtime_sdk-1.6.14 → workers_runtime_sdk-1.7.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.14 → workers_runtime_sdk-1.7.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.14 → workers_runtime_sdk-1.7.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.14 → workers_runtime_sdk-1.7.0}/tests/web-frameworks-test/fastapi-tests/src/_client.py

@@ -46,6 +46,23 @@ 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}"
+
+
 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.7.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.6.14 → workers_runtime_sdk-1.7.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.7.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()

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

@@ -1,5 +1,6 @@
 import asyncio
 import enum
+import hashlib
 import importlib.util
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -15,6 +16,7 @@ from fastapi import (
     Query,
     Request,
     UploadFile,
+    WebSocket,
 )
 from fastapi.exceptions import HTTPException
 from fastapi.responses import (
@@ -32,7 +34,6 @@ from pyodide.webloop import WebLoop
 from starlette.background import BackgroundTask
 
 import asgi
-from workers import Response, WorkerEntrypoint
 
 
 async def _noop(*args):
@@ -82,6 +83,14 @@ async def health():
     return {"ok": True}
 
 
+@app.websocket("/websocket/echo")
+async def websocket_echo(websocket: WebSocket):
+    await websocket.accept()
+    message = await websocket.receive_text()
+    await websocket.send_text(f"echo:{message}")
+    await websocket.close()
+
+
 # -- sync route handler (dispatched via run_in_threadpool) -------------------
 @app.get("/sync/hello")
 def sync_hello():
@@ -436,6 +445,24 @@ async def platform_lifespan_state(request: Request):
     return {"available": True, "closed": resource.closed}
 
 
+# --------------------------------------------------------------------------- #
+# Pyodide and Workers platform boundary routes
+# --------------------------------------------------------------------------- #
+
+
+@app.post("/platform/upload-spooled")
+async def platform_upload_spooled(file: UploadFile = File(...)):  # noqa: B008
+    first = await file.read()
+    await file.seek(0)
+    second = await file.read()
+    return {
+        "size": len(first),
+        "sha256": hashlib.sha256(first).hexdigest(),
+        "reread_matches": first == second,
+        "rolled_to_disk": bool(getattr(file.file, "_rolled", False)),
+    }
+
+
 @app.get("/native-file")
 async def native_file():
     """Serve a single bundled file with FastAPI's native FileResponse."""
@@ -447,17 +474,6 @@ async def native_file():
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 
-@app.get("/{path:path}")
-async def frontend(path: str, request: Request):
-    """Proxy static asset requests to the Workers Assets binding."""
-    env = request.scope["env"]
-    asset_url = f"https://assets.local/{path}"
-    resp = await env.ASSETS.fetch(asset_url)
-    body = await resp.bytes()
-    headers = dict(resp.headers)
-    return FastAPIResponse(content=body, status_code=resp.status, headers=headers)
-
-
 class ResultCollector:
     def __init__(self):
         self.results = {}
@@ -524,37 +540,40 @@ class FastAPIAppPlugin:
         return app
 
 
-class Default(WorkerEntrypoint):
-    async def fetch(self, request):
-        from urllib.parse import urlparse
-
-        path = urlparse(request.url).path
-
-        if path.startswith("/run-tests/"):
-            suite_name = path[len("/run-tests/") :]
-            return self._run_suite(suite_name)
-
-        return await asgi.fetch(app, request, self.env, self.ctx)
-
-    def _run_suite(self, suite_name):
-        module = f"test_{suite_name}"
-        if importlib.util.find_spec(module) is None:
-            return Response.json(
-                {"error": f"Unknown suite '{suite_name}' (no module '{module}')"},
-                status=404,
-            )
-
-        collector = ResultCollector()
-        saved_loop = asyncio.events._get_running_loop()
-        try:
-            pytest.main(
-                ["--pyargs", module, "-p", "no:cacheprovider"],
-                plugins=[
-                    collector,
-                    EnvPlugin(self.env),
-                    FastAPIAppPlugin(),
-                ],
-            )
-        finally:
-            asyncio.events._set_running_loop(saved_loop)
-        return Response.json(collector.results)
+@app.get("/run-tests/{suite_name:path}")
+async def run_suite(suite_name: str, request: Request):
+    module = f"test_{suite_name}"
+    if importlib.util.find_spec(module) is None:
+        return JSONResponse(
+            {"error": f"Unknown suite '{suite_name}' (no module '{module}')"},
+            status_code=404,
+        )
+
+    collector = ResultCollector()
+    saved_loop = asyncio.events._get_running_loop()
+    try:
+        pytest.main(
+            ["--pyargs", module, "-p", "no:cacheprovider"],
+            plugins=[
+                collector,
+                EnvPlugin(request.scope["env"]),
+                FastAPIAppPlugin(),
+            ],
+        )
+    finally:
+        asyncio.events._set_running_loop(saved_loop)
+    return collector.results
+
+
+@app.get("/{path:path}")
+async def frontend(path: str, request: Request):
+    """Proxy static asset requests to the Workers Assets binding."""
+    env = request.scope["env"]
+    asset_url = f"https://assets.local/{path}"
+    resp = await env.ASSETS.fetch(asset_url)
+    body = await resp.bytes()
+    headers = dict(resp.headers)
+    return FastAPIResponse(content=body, status_code=resp.status, headers=headers)
+
+
+Default = asgi.entrypoint(app)

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

@@ -140,3 +140,22 @@ async def test_empty_frames_reach_the_client():
         assert messages[0] == ""
         assert messages[1].to_bytes() == b""
         assert messages[2] == "done"
+
+
+@pytest.mark.asyncio
+async def test_application_close_reaches_client_with_code_and_reason():
+    async with _ws_session("/ws-close") as ws:
+        closed = _listen(ws, "close")
+        ws.send("close")
+        event = await asyncio.wait_for(closed, TIMEOUT_S)
+        assert event.code == 4001
+        assert event.reason == "application-close"
+
+
+@pytest.mark.asyncio
+async def test_environment_reaches_websocket_scope():
+    async with _ws_session("/ws-env") as ws:
+        message = _listen(ws, "message")
+        ws.send("env")
+        event = await asyncio.wait_for(message, TIMEOUT_S)
+        assert event.data == "worker-environment"

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

@@ -101,16 +101,58 @@ class WSEmptyFrameApp:
             await send({"type": "websocket.send", "text": "done"})
 
 
+class WSCloseApp:
+    """Closes the connection with an application-provided code and reason."""
+
+    async def __call__(self, scope, receive, send):
+        message = await receive()
+        assert message["type"] == "websocket.connect"
+        await send({"type": "websocket.accept"})
+        message = await receive()
+        if message["type"] == "websocket.disconnect":
+            return
+        await send(
+            {
+                "type": "websocket.close",
+                "code": 4001,
+                "reason": "application-close",
+            }
+        )
+
+
+class WSEnvApp:
+    """Sends a value supplied through the ASGI WebSocket scope environment."""
+
+    async def __call__(self, scope, receive, send):
+        message = await receive()
+        assert message["type"] == "websocket.connect"
+        await send({"type": "websocket.accept"})
+        message = await receive()
+        if message["type"] == "websocket.disconnect":
+            return
+        await send({"type": "websocket.send", "text": scope["env"]["marker"]})
+
+
 ws_app = WSWatchApp()
 echo_app = WSEchoApp()
 empty_frame_app = WSEmptyFrameApp()
+close_app = WSCloseApp()
+env_app = WSEnvApp()
 
 
 class Default(WorkerEntrypoint):
     async def fetch(self, request):
         if (request.headers.get("upgrade") or "").lower() == "websocket":
             path = urlsplit(request.url).path
-            app = {"/ws-echo": echo_app, "/ws-empty": empty_frame_app}.get(path, ws_app)
+            if path == "/ws-env":
+                return await asgi.websocket(
+                    env_app, request, {"marker": "worker-environment"}
+                )
+            app = {
+                "/ws-close": close_app,
+                "/ws-echo": echo_app,
+                "/ws-empty": empty_frame_app,
+            }.get(path, ws_app)
             return await asgi.websocket(app, request)
         import json
 

{workers_runtime_sdk-1.6.14 → workers_runtime_sdk-1.7.0}/tests/workerd-test/sdk/tests/test_sdk.py

@@ -436,6 +436,11 @@ async def test_request_unit_tests():
     blob = await req_for_blob.blob()
     assert (await blob.text()) == "foobar"
 
+    # Verify that Python bytes are converted without UTF-8 decoding or truncation.
+    binary_body = bytes(range(256))
+    req_for_bytes = Request("http://example.com", body=binary_body, method="POST")
+    assert await req_for_bytes.bytes() == binary_body
+
     # Verify that we can get a FormData back.
     js_form_data = js.FormData.new()
     js_form_data.append("foobar", 123)

{workers_runtime_sdk-1.6.14 → workers_runtime_sdk-1.7.0}/uv.lock

@@ -345,7 +345,7 @@ wheels = [
 
 [[package]]
 name = "workers-runtime-sdk"
-version = "1.6.14"
+version = "1.7.0"
 source = { editable = "." }
 
 [package.dev-dependencies]