workers-runtime-sdk 1.6.11__tar.gz → 1.6.12__tar.gz

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 <!-- version list -->
 
+## v1.6.12 (2026-08-11)
+
+### Bug Fixes
+
+- **runtime-sdk**: Send empty WebSocket frames instead of dropping them
+  ([#165](https://github.com/cloudflare/workers-py/pull/165),
+  [`a4128ce`](https://github.com/cloudflare/workers-py/commit/a4128cee402aa6f28f01e3e2268241d05d9fd393))
+
+
 ## v1.6.11 (2026-08-10)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/PKG-INFO

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

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

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/src/asgi.py

@@ -352,12 +352,12 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
         if got["type"] == "websocket.send":
             b = got.get("bytes", None)
             s = got.get("text", None)
-            if b:
+            if b is not None:
                 with acquire_js_buffer(b) as jsbytes:
                     # Unlike the `Response` constructor,  server.send seems to
                     # eagerly copy the source buffer
                     server.send(jsbytes)
-            if s:
+            if s is not None:
                 server.send(s)
 
         else:

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -26,6 +26,22 @@ def _listen(ws, event_type):
     return fut
 
 
+def _collect(ws, count):
+    """Future resolved with the payloads of the first `count` messages."""
+    fut = asyncio.get_event_loop().create_future()
+    messages = []
+
+    def callback(evt):
+        messages.append(evt.data)
+        if len(messages) == count and not fut.done():
+            fut.set_result(messages)
+
+    proxy = create_proxy(callback)
+    _proxies.append(proxy)
+    ws.addEventListener("message", proxy)
+    return fut
+
+
 async def _ws_connect(path):
     # Upgrade through the raw JS binding (as durable-object-websocket's
     # tester.js does): the SDK fetch wrapper routes through pyfetch, whose
@@ -113,3 +129,14 @@ async def test_binary_frame_arrives_as_asgi_bytes():
         data = evt.data
         assert not isinstance(data, str), f"delivered to the app as text: {data!r}"
         assert data.to_bytes() == b"bytes=" + payload
+
+
+@pytest.mark.asyncio
+async def test_empty_frames_reach_the_client():
+    async with _ws_session("/ws-empty") as ws:
+        received = _collect(ws, 3)
+        ws.send("go")
+        messages = await asyncio.wait_for(received, TIMEOUT_S)
+        assert messages[0] == ""
+        assert messages[1].to_bytes() == b""
+        assert messages[2] == "done"

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/tests/workerd-test/asgi-ws-disconnect/worker.py

@@ -80,15 +80,37 @@ class WSEchoApp:
                 await send({"type": "websocket.send", "text": reply})
 
 
+class WSEmptyFrameApp:
+    """On each client frame, replies with an empty text frame, an empty binary
+    frame, and a sentinel, so a test can tell whether empty frames reach the
+    client at all."""
+
+    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"})
+        while True:
+            message = await receive()
+            if message["type"] == "websocket.disconnect":
+                return
+            await send({"type": "websocket.send", "text": ""})
+            await send({"type": "websocket.send", "bytes": b""})
+            await send({"type": "websocket.send", "text": "done"})
+
+
 ws_app = WSWatchApp()
 echo_app = WSEchoApp()
+empty_frame_app = WSEmptyFrameApp()
 
 
 class Default(WorkerEntrypoint):
     async def fetch(self, request):
         if (request.headers.get("upgrade") or "").lower() == "websocket":
             path = urlsplit(request.url).path
-            app = echo_app if path == "/ws-echo" else ws_app
+            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.12/tests/workerd-test/wsgi/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "test"
+version = "0.0.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0"]

workers_runtime_sdk-1.6.12/tests/workerd-test/wsgi/tests/test_wsgi.py

@@ -0,0 +1,105 @@
+import json
+
+import js
+import pytest
+from pyodide.ffi import to_js
+from worker import (
+    STREAMING_CHUNK_SIZE,
+    STREAMING_NUM_CHUNKS,
+    crash_app,
+    example_hdr,
+)
+
+from workers import Request, env, wsgi
+
+
+@pytest.mark.asyncio
+async def test_headers():
+    response = await env.SELF.fetch("http://example.com/", headers=to_js(example_hdr))
+    assert response.status == 200
+    text = await response.text()
+    assert text == "Hello, World"
+    # Echoed-back headers should be present.
+    assert response.headers.get("header1") == "Value1"
+    assert response.headers.get("header2") == "Value2"
+
+
+@pytest.mark.asyncio
+async def test_echo_body():
+    response = await env.SELF.fetch(
+        "http://example.com/echo-body",
+        method="POST",
+        body="hello body",
+    )
+    assert response.status == 200
+    text = await response.text()
+    assert text == "hello body"
+
+
+@pytest.mark.asyncio
+async def test_meta():
+    response = await env.SELF.fetch("http://example.com/meta?foo=bar&baz=qux")
+    assert response.status == 200
+
+    payload = json.loads(await response.text())
+    assert payload["method"] == "GET"
+    assert payload["path"] == "/meta"
+    assert payload["query"] == "foo=bar&baz=qux"
+    assert payload["scheme"] == "http"
+    assert payload["has_env"] is True
+
+
+@pytest.mark.asyncio
+async def test_cookies():
+    response = await env.SELF.fetch("http://example.com/cookies")
+    assert response.status == 200
+    # `env.SELF.fetch` returns the SDK `FetchResponse`, whose `.headers` is an
+    # `http.client.HTTPMessage`. Repeated Set-Cookie headers are preserved as
+    # separate entries (see `python_request_headers_preserve_commas`), so use
+    # `get_all` to recover the individual values.
+    cookies = response.headers.get_all("Set-Cookie")
+    assert "a=1" in cookies
+    assert "b=2" in cookies
+
+
+@pytest.mark.asyncio
+async def test_streaming():
+    response = await env.SELF.fetch("http://example.com/stream")
+    assert response.status == 200
+    assert response.headers.get("content-type") == "application/octet-stream"
+
+    reader = response.body.getReader()
+    body_bytes = b""
+    while True:
+        result = await reader.read()
+        if result.done:
+            break
+        body_bytes += result.value.to_bytes()
+
+    expected_size = STREAMING_CHUNK_SIZE * STREAMING_NUM_CHUNKS
+    assert len(body_bytes) == expected_size, (
+        f"Expected {expected_size} bytes, got {len(body_bytes)}"
+    )
+    for i in range(STREAMING_NUM_CHUNKS):
+        start = i * STREAMING_CHUNK_SIZE
+        end = start + STREAMING_CHUNK_SIZE
+        expected_byte = i % 256
+        assert all(b == expected_byte for b in body_bytes[start:end])
+
+
+@pytest.mark.asyncio
+async def test_app_exception_is_raised():
+    req = js.Request.new("http://example.com/crash-test")
+    with pytest.raises(RuntimeError, match="app crash before response for testing"):
+        await wsgi.fetch(crash_app, req, env)
+
+
+def test_build_environ_handles_js_and_python_requests():
+    # Verify `build_environ` handles JS-style and Python-style headers
+    # identically, mirroring the asgi `request_to_scope` check.
+    js_request = js.Request.new("http://example.com/", headers=to_js(example_hdr))
+    py_request = Request("http://example.com/", headers=example_hdr)
+    js_env = wsgi.build_environ(js_request, env, b"")
+    py_env = wsgi.build_environ(py_request, env, b"")
+    assert js_env["HTTP_HEADER1"] == py_env["HTTP_HEADER1"] == "Value1"
+    assert js_env["HTTP_HEADER2"] == py_env["HTTP_HEADER2"] == "Value2"

workers_runtime_sdk-1.6.12/tests/workerd-test/wsgi/worker.py

@@ -0,0 +1,131 @@
+import asyncio
+import os
+import sys
+
+import pytest
+from pyodide.webloop import WebLoop
+
+from workers import WorkerEntrypoint, wsgi
+
+
+async def noop(*args):
+    pass
+
+
+# pytest-asyncio relies on these but in Pyodide < 0.29 WebLoop does not implement them
+WebLoop.shutdown_asyncgens = noop
+WebLoop.shutdown_default_executor = noop
+
+# Pyodide 0.26.0a2's _cancel_all_tasks calls task.exception() on pending tasks,
+# which raises InvalidStateError under Pyodide's WebLoop.
+# Ignore this error to prevent pytest-asyncio from crashing.
+if sys.version_info < (3, 13):
+    asyncio.runners._cancel_all_tasks = lambda loop: None  # type: ignore[attr-defined]
+
+
+# ---------------------------------------------------------------------------
+# WSGI apps
+# ---------------------------------------------------------------------------
+
+
+def header_echo_app(environ, start_response):
+    """WSGI app that echoes request headers back in the response body and headers."""
+    response_headers = [("Content-Type", "text/plain")]
+    # Echo each incoming header back out (HTTP_* keys).
+    for key, value in environ.items():
+        if key.startswith("HTTP_"):
+            name = key[len("HTTP_") :].replace("_", "-").title()
+            response_headers.append((name, value))
+
+    start_response("200 OK", response_headers)
+    return [b"Hello, World"]
+
+
+def echo_body_app(environ, start_response):
+    """WSGI app that reads the request body and echoes it back."""
+    length = int(environ.get("CONTENT_LENGTH") or 0)
+    body = environ["wsgi.input"].read(length)
+    start_response(
+        "200 OK",
+        [("Content-Type", "application/octet-stream")],
+    )
+    return [body]
+
+
+def echo_meta_app(environ, start_response):
+    """WSGI app that returns selected environ values so the test can assert on them."""
+    import json
+
+    payload = {
+        "method": environ["REQUEST_METHOD"],
+        "path": environ["PATH_INFO"],
+        "query": environ["QUERY_STRING"],
+        "scheme": environ["wsgi.url_scheme"],
+        "has_env": "workers.env" in environ,
+    }
+    body = json.dumps(payload).encode()
+    start_response("200 OK", [("Content-Type", "application/json")])
+    return [body]
+
+
+def cookies_app(environ, start_response):
+    """WSGI app that sets multiple Set-Cookie headers (must not collapse)."""
+    start_response(
+        "200 OK",
+        [
+            ("Content-Type", "text/plain"),
+            ("Set-Cookie", "a=1"),
+            ("Set-Cookie", "b=2"),
+        ],
+    )
+    return [b"cookies"]
+
+
+STREAMING_CHUNK_SIZE = 1024
+STREAMING_NUM_CHUNKS = 5
+
+
+def streaming_app(environ, start_response):
+    """WSGI app that returns multiple body chunks via a generator."""
+    start_response("200 OK", [("Content-Type", "application/octet-stream")])
+
+    def generate():
+        for i in range(STREAMING_NUM_CHUNKS):
+            yield bytes([i % 256]) * STREAMING_CHUNK_SIZE
+
+    return generate()
+
+
+def crash_app(environ, start_response):
+    raise RuntimeError("app crash before response for testing")
+
+
+example_hdr = {"Header1": "Value1", "Header2": "Value2"}
+
+
+class Default(WorkerEntrypoint):
+    # Each path in this handler serves one of the WSGI apps above; the
+    # assertions live in tests/test_wsgi.py.
+    async def fetch(self, request):
+        from js import URL
+
+        url = URL.new(request.url)
+        path = url.pathname
+
+        if path == "/echo-body":
+            return await wsgi.fetch(echo_body_app, request, self.env)
+        elif path == "/meta":
+            return await wsgi.fetch(echo_meta_app, request, self.env)
+        elif path == "/cookies":
+            return await wsgi.fetch(cookies_app, request, self.env)
+        elif path == "/stream":
+            return await wsgi.fetch(streaming_app, request, self.env)
+
+        return await wsgi.fetch(header_echo_app, request, self.env)
+
+    async def test(self, ctrl):
+        os.chdir("/session/metadata/tests")
+        args = [".", "-vv"]
+        if self.env.color:
+            args.append("--color=yes")
+        assert pytest.main(args) == 0

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/tests/workerd-test/wsgi/wsgi.wd-test

@@ -10,6 +10,10 @@ const unitTests :Workerd.Config = (
         ],
         bindings = [
           ( name = "SELF", service = "python-wsgi" ),
+          (
+            name = "color",
+            json = "%COLOR"
+          ),
         ],
         compatibilityDate = "%COMPAT_DATE",
         compatibilityFlags = ["python_workers"],

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.12}/uv.lock

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

workers_runtime_sdk-1.6.11/tests/workerd-test/wsgi/pyproject.toml

@@ -1,5 +0,0 @@
-[project]
-name = "test"
-version = "0.0.0"
-requires-python = ">=3.12"
-dependencies = ["pytest"]

workers_runtime_sdk-1.6.11/tests/workerd-test/wsgi/worker.py

@@ -1,205 +0,0 @@
-import js
-from pyodide.ffi import to_js
-
-from workers import Request, WorkerEntrypoint, wsgi
-
-# ---------------------------------------------------------------------------
-# WSGI apps
-# ---------------------------------------------------------------------------
-
-
-def header_echo_app(environ, start_response):
-    """WSGI app that echoes request headers back in the response body and headers."""
-    response_headers = [("Content-Type", "text/plain")]
-    # Echo each incoming header back out (HTTP_* keys).
-    for key, value in environ.items():
-        if key.startswith("HTTP_"):
-            name = key[len("HTTP_") :].replace("_", "-").title()
-            response_headers.append((name, value))
-
-    start_response("200 OK", response_headers)
-    return [b"Hello, World"]
-
-
-def echo_body_app(environ, start_response):
-    """WSGI app that reads the request body and echoes it back."""
-    length = int(environ.get("CONTENT_LENGTH") or 0)
-    body = environ["wsgi.input"].read(length)
-    start_response(
-        "200 OK",
-        [("Content-Type", "application/octet-stream")],
-    )
-    return [body]
-
-
-def echo_meta_app(environ, start_response):
-    """WSGI app that returns selected environ values so the test can assert on them."""
-    import json
-
-    payload = {
-        "method": environ["REQUEST_METHOD"],
-        "path": environ["PATH_INFO"],
-        "query": environ["QUERY_STRING"],
-        "scheme": environ["wsgi.url_scheme"],
-        "has_env": "workers.env" in environ,
-    }
-    body = json.dumps(payload).encode()
-    start_response("200 OK", [("Content-Type", "application/json")])
-    return [body]
-
-
-def cookies_app(environ, start_response):
-    """WSGI app that sets multiple Set-Cookie headers (must not collapse)."""
-    start_response(
-        "200 OK",
-        [
-            ("Content-Type", "text/plain"),
-            ("Set-Cookie", "a=1"),
-            ("Set-Cookie", "b=2"),
-        ],
-    )
-    return [b"cookies"]
-
-
-STREAMING_CHUNK_SIZE = 1024
-STREAMING_NUM_CHUNKS = 5
-
-
-def streaming_app(environ, start_response):
-    """WSGI app that returns multiple body chunks via a generator."""
-    start_response("200 OK", [("Content-Type", "application/octet-stream")])
-
-    def generate():
-        for i in range(STREAMING_NUM_CHUNKS):
-            yield bytes([i % 256]) * STREAMING_CHUNK_SIZE
-
-    return generate()
-
-
-def crash_app(environ, start_response):
-    raise RuntimeError("app crash before response for testing")
-
-
-example_hdr = {"Header1": "Value1", "Header2": "Value2"}
-
-
-class Default(WorkerEntrypoint):
-    async def fetch(self, request):
-        from js import URL
-
-        url = URL.new(request.url)
-        path = url.pathname
-
-        if path == "/echo-body":
-            return await wsgi.fetch(echo_body_app, request, self.env)
-        elif path == "/meta":
-            return await wsgi.fetch(echo_meta_app, request, self.env)
-        elif path == "/cookies":
-            return await wsgi.fetch(cookies_app, request, self.env)
-        elif path == "/stream":
-            return await wsgi.fetch(streaming_app, request, self.env)
-
-        # Verify `build_environ` handles JS-style and Python-style headers
-        # identically, mirroring the asgi `request_to_scope` check.
-        js_request = js.Request.new("http://example.com/", headers=to_js(example_hdr))
-        py_request = Request("http://example.com/", headers=example_hdr)
-        js_env = wsgi.build_environ(js_request, self.env, b"")
-        py_env = wsgi.build_environ(py_request, self.env, b"")
-        assert js_env["HTTP_HEADER1"] == py_env["HTTP_HEADER1"] == "Value1"
-        assert js_env["HTTP_HEADER2"] == py_env["HTTP_HEADER2"] == "Value2"
-
-        return await wsgi.fetch(header_echo_app, request, self.env)
-
-    async def test(self, ctrl):
-        await test_headers(self.env)
-        await test_echo_body(self.env)
-        await test_meta(self.env)
-        await test_cookies(self.env)
-        await test_streaming(self.env)
-        await test_app_exception_is_raised(self.env)
-
-
-# ---------------------------------------------------------------------------
-# Tests
-# ---------------------------------------------------------------------------
-
-
-async def test_headers(env):
-    response = await env.SELF.fetch("http://example.com/", headers=to_js(example_hdr))
-    assert response.status == 200
-    text = await response.text()
-    assert text == "Hello, World"
-    # Echoed-back headers should be present.
-    assert response.headers.get("header1") == "Value1"
-    assert response.headers.get("header2") == "Value2"
-
-
-async def test_echo_body(env):
-    response = await env.SELF.fetch(
-        "http://example.com/echo-body",
-        method="POST",
-        body="hello body",
-    )
-    assert response.status == 200
-    text = await response.text()
-    assert text == "hello body"
-
-
-async def test_meta(env):
-    response = await env.SELF.fetch("http://example.com/meta?foo=bar&baz=qux")
-    assert response.status == 200
-    import json
-
-    payload = json.loads(await response.text())
-    assert payload["method"] == "GET"
-    assert payload["path"] == "/meta"
-    assert payload["query"] == "foo=bar&baz=qux"
-    assert payload["scheme"] == "http"
-    assert payload["has_env"] is True
-
-
-async def test_cookies(env):
-    response = await env.SELF.fetch("http://example.com/cookies")
-    assert response.status == 200
-    # `env.SELF.fetch` returns the SDK `FetchResponse`, whose `.headers` is an
-    # `http.client.HTTPMessage`. Repeated Set-Cookie headers are preserved as
-    # separate entries (see `python_request_headers_preserve_commas`), so use
-    # `get_all` to recover the individual values.
-    cookies = response.headers.get_all("Set-Cookie")
-    assert "a=1" in cookies
-    assert "b=2" in cookies
-
-
-async def test_streaming(env):
-    response = await env.SELF.fetch("http://example.com/stream")
-    assert response.status == 200
-    assert response.headers.get("content-type") == "application/octet-stream"
-
-    reader = response.body.getReader()
-    body_bytes = b""
-    while True:
-        result = await reader.read()
-        if result.done:
-            break
-        body_bytes += result.value.to_bytes()
-
-    expected_size = STREAMING_CHUNK_SIZE * STREAMING_NUM_CHUNKS
-    assert len(body_bytes) == expected_size, (
-        f"Expected {expected_size} bytes, got {len(body_bytes)}"
-    )
-    for i in range(STREAMING_NUM_CHUNKS):
-        start = i * STREAMING_CHUNK_SIZE
-        end = start + STREAMING_CHUNK_SIZE
-        expected_byte = i % 256
-        assert all(b == expected_byte for b in body_bytes[start:end])
-
-
-async def test_app_exception_is_raised(env):
-    req = js.Request.new("http://example.com/crash-test")
-    threw = False
-    try:
-        await wsgi.fetch(crash_app, req, env)
-    except RuntimeError as e:
-        threw = True
-        assert "app crash before response for testing" in str(e)
-    assert threw, "Expected RuntimeError to be raised from wsgi.fetch"