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

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

@@ -2,6 +2,23 @@
 
 <!-- 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
+
+- Implements tests for FastAPI StaticFiles and anyio thread patch
+  ([`a30f53e`](https://github.com/cloudflare/workers-py/commit/a30f53e95edcf42fc93e5e2dc84251121881418b))
+
+
 ## v1.6.10 (2026-08-10)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.10 → 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.10
+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.10 → workers_runtime_sdk-1.6.12}/pyproject.toml

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

workers_runtime_sdk-1.6.12/src/_workers_sdk_package_patches.py

@@ -0,0 +1,45 @@
+"""
+Top level runtime compatibility patches for packages.
+
+These patches adapt packages that assume capabilities the workers runtime does
+not provide. Unlike the entropy patches, they are not related to snapshotting.
+"""
+
+from contextlib import contextmanager
+
+from _cloudflare.import_patch_manager import (
+    register_exec_patch,
+)
+
+
+@register_exec_patch("anyio.to_thread")
+@contextmanager
+def anyio_to_thread_context(module):
+    """`anyio.to_thread.run_sync` dispatches blocking work to an OS thread, but the
+    workers runtime is single threaded, so starting a thread raises
+    `RuntimeError: can't start new thread`. Run the callable inline instead.
+
+    This function is the only caller of `run_sync_in_worker_thread`, which makes it
+    the single chokepoint for every blocking call anyio makes on behalf of a
+    framework. In starlette/fastapi that covers sync route handlers, sync
+    dependencies, `StaticFiles`, `FileResponse`, `UploadFile`, `BackgroundTask` and
+    `GZipMiddleware`, as well as `anyio.Path` and `anyio.open_file`.
+
+    Patching the module attribute is enough because every caller looks it up at
+    call time (e.g. `starlette.concurrency` and `anyio._core._fileio` both import
+    the module rather than the function).
+
+    We patch `anyio.to_thread` rather than the backend's
+    `run_sync_in_worker_thread` because `anyio._backends._asyncio` is imported
+    lazily by `get_async_backend()` during a request, by which point the import
+    patch manager is no longer installed.
+    """
+    yield
+
+    async def run_sync(func, *args, **kwargs):
+        # Callers pass the function's own arguments positionally and anyio's
+        # options (`limiter`, `abandon_on_cancel`, `cancellable`) as keywords.
+        # None of the options mean anything without threads, so drop them.
+        return func(*args)
+
+    module.run_sync = run_sync

workers_runtime_sdk-1.6.12/src/_workers_sdk_patch_loader.pth

@@ -0,0 +1 @@
+import _workers_sdk_patch_loader

workers_runtime_sdk-1.6.12/src/_workers_sdk_patch_loader.py

@@ -0,0 +1,16 @@
+"""
+Loader shim for the top level package patches.
+
+This module is imported by the .pth file on every Python startup. The patches
+depend on the `_cloudflare` package, which only exists inside the workers
+runtime. When running outside of the workers runtime, `_cloudflare` is not
+available, so we silently skip loading the patches. Skipping is also what we
+want in that case: the patches adapt packages to the workers runtime and should
+not change how they behave under native Python.
+"""
+
+import importlib.util
+
+if importlib.util.find_spec("_cloudflare") is not None:
+    import _workers_sdk_entropy_import_context  # noqa: F401
+    import _workers_sdk_package_patches  # noqa: F401

{workers_runtime_sdk-1.6.10 → 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.12/tests/web-frameworks-test/fastapi-tests/src/static/app.css

@@ -0,0 +1,4 @@
+body {
+    font-family: monospace;
+    color: rebeccapurple;
+}

workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests/src/static/data.json

@@ -0,0 +1 @@
+{"source": "staticfiles", "number": 7}

workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests/src/static/hello.txt

@@ -0,0 +1 @@
+Hello from StaticFiles

workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests/src/static/index.html

@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+<head><title>FastAPI StaticFiles Test</title></head>
+<body>
+<h1>Hello from StaticFiles</h1>
+</body>
+</html>

workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests/src/test_staticfiles.py

@@ -0,0 +1,117 @@
+"""Tests for FastAPI's native static file APIs (StaticFiles and FileResponse).
+
+Unlike ``test_assets.py``, which proxies to the Workers Assets binding, these
+tests exercise Starlette's own filesystem-backed static file serving against
+files bundled into the worker under ``src/static/``.
+"""
+
+import pytest
+from _client import fetch, get_json, read_json
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_serves_text(fastapi_app):
+    """Mounted StaticFiles app serves a bundled text file."""
+    resp = await fetch(fastapi_app, "/static/hello.txt")
+    assert resp.status == 200
+    text = await resp.text()
+    assert "Hello from StaticFiles" in text
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_serves_html(fastapi_app):
+    """Mounted StaticFiles app serves a bundled HTML file."""
+    resp = await fetch(fastapi_app, "/static/index.html")
+    assert resp.status == 200
+    text = await resp.text()
+    assert "Hello from StaticFiles" in text
+    assert "<!doctype html>" in text.lower()
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_guesses_content_type(fastapi_app):
+    """StaticFiles infers the content type from the file extension."""
+    resp = await fetch(fastapi_app, "/static/app.css")
+    assert resp.status == 200
+    assert "css" in resp.headers.get("content-type")
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_serves_json(fastapi_app):
+    """StaticFiles serves a JSON file that is parseable and correctly typed."""
+    resp = await fetch(fastapi_app, "/static/data.json")
+    assert resp.status == 200
+    assert "application/json" in resp.headers.get("content-type")
+    data = await read_json(resp)
+    assert data["source"] == "staticfiles"
+    assert data["number"] == 7
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_sets_content_length(fastapi_app):
+    """StaticFiles reports the on-disk size and sends exactly that many bytes."""
+    resp = await fetch(fastapi_app, "/static/hello.txt")
+    assert resp.status == 200
+    content_length = resp.headers.get("content-length")
+    assert content_length is not None
+    body = (await resp.text()).encode()
+    assert len(body) == int(content_length)
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_sets_validators(fastapi_app):
+    """StaticFiles derives etag and last-modified headers from the file stat."""
+    resp = await fetch(fastapi_app, "/static/hello.txt")
+    assert resp.status == 200
+    assert resp.headers.get("etag")
+    assert resp.headers.get("last-modified")
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_honours_if_none_match(fastapi_app):
+    """A conditional request matching the etag gets a 304 with no body."""
+    first = await fetch(fastapi_app, "/static/hello.txt")
+    etag = first.headers.get("etag")
+    assert etag
+
+    second = await fetch(
+        fastapi_app, "/static/hello.txt", headers={"if-none-match": etag}
+    )
+    assert second.status == 304
+    assert await second.text() == ""
+
+
+@pytest.mark.asyncio
+async def test_staticfiles_missing_file_returns_404(fastapi_app):
+    """StaticFiles returns 404 for a file that is not bundled."""
+    resp = await fetch(fastapi_app, "/static/nonexistent.txt")
+    assert resp.status == 404
+
+
+@pytest.mark.asyncio
+async def test_file_response_serves_file(fastapi_app):
+    """A route returning FileResponse streams the bundled file."""
+    resp = await fetch(fastapi_app, "/native-file")
+    assert resp.status == 200
+    assert "text/plain" in resp.headers.get("content-type")
+    text = await resp.text()
+    assert "Hello from StaticFiles" in text
+
+
+@pytest.mark.asyncio
+async def test_file_response_sets_content_length(fastapi_app):
+    """FileResponse reports the on-disk size and sends exactly that many bytes."""
+    resp = await fetch(fastapi_app, "/native-file")
+    assert resp.status == 200
+    content_length = resp.headers.get("content-length")
+    assert content_length is not None
+    body = (await resp.text()).encode()
+    assert len(body) == int(content_length)
+
+
+@pytest.mark.asyncio
+async def test_api_route_still_works(fastapi_app, env):
+    """API routes are unaffected by the StaticFiles mount."""
+    resp, data = await get_json(fastapi_app, "/api/hello", env=env)
+    assert resp.status == 200
+    assert data["message"] == "Hello from FastAPI"

{workers_runtime_sdk-1.6.10 → workers_runtime_sdk-1.6.12}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -1,9 +1,12 @@
 import asyncio
 import importlib.util
+from pathlib import Path
 
 import pytest
 from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse
 from fastapi.responses import Response as FastAPIResponse
+from fastapi.staticfiles import StaticFiles
 from pyodide.webloop import WebLoop
 
 import asgi
@@ -17,6 +20,8 @@ async def _noop(*args):
 WebLoop.shutdown_asyncgens = _noop
 WebLoop.shutdown_default_executor = _noop
 
+STATIC_DIR = Path(__file__).parent / "static"
+
 app = FastAPI()
 
 
@@ -30,6 +35,17 @@ async def health():
     return {"ok": True}
 
 
+@app.get("/native-file")
+async def native_file():
+    """Serve a single bundled file with FastAPI's native FileResponse."""
+    return FileResponse(STATIC_DIR / "hello.txt", media_type="text/plain")
+
+
+# Mounted before the catch-all below so `/static/*` is handled by Starlette's
+# own filesystem-backed static file app rather than the Assets binding.
+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."""

workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests/wrangler.jsonc

@@ -0,0 +1,21 @@
+{
+    "name": "fastapi-tests",
+    "main": "src/worker.py",
+    "compatibility_date": "%COMPAT_DATE",
+    "compatibility_flags": ["python_workers"],
+    // Only `**/*.txt` and `**/*.html` are bundled as Text by default, so the
+    // other `src/static/` fixtures would never reach the Pyodide filesystem for
+    // StaticFiles to read. `fallthrough` keeps the default Text rule as well.
+    "rules": [
+        {
+            "type": "Text",
+            "globs": ["static/*.css", "static/*.json"],
+            "fallthrough": true
+        }
+    ],
+    "assets": {
+        "directory": "./public/",
+        "binding": "ASSETS",
+        "run_worker_first": true
+    }
+}

{workers_runtime_sdk-1.6.10 → 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.10 → 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.10 → 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.10 → workers_runtime_sdk-1.6.12}/uv.lock

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

workers_runtime_sdk-1.6.10/src/_workers_sdk_entropy_import_context.pth

@@ -1 +0,0 @@
-import _workers_sdk_entropy_import_context_loader