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

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

@@ -2,6 +2,23 @@
 
 <!-- version list -->
 
+## 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
+
+- **runtime-sdk**: Terminate the response stream when the app fails mid-stream
+  ([#168](https://github.com/cloudflare/workers-py/pull/168),
+  [`fd4dde9`](https://github.com/cloudflare/workers-py/commit/fd4dde98fcc39f405a7cf320a6db49a83426f46b))
+
+
 ## v1.6.9 (2026-08-10)
 
 ### Bug Fixes

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

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

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

workers_runtime_sdk-1.6.11/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.11/src/_workers_sdk_patch_loader.pth

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

workers_runtime_sdk-1.6.11/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.9 → workers_runtime_sdk-1.6.11}/src/asgi.py

@@ -28,6 +28,13 @@ def run_in_background(coro: Awaitable[Any]) -> None:
     fut.add_done_callback(_on_done)
 
 
+async def close_stream_quietly(writer):
+    try:
+        await writer.close()
+    except Exception:
+        logger.debug("Closing the response stream failed", exc_info=True)
+
+
 @contextmanager
 def acquire_js_buffer(pybuffer):
     from pyodide.ffi import create_proxy
@@ -182,6 +189,7 @@ async def process_request(
 
     # Streaming state — initialized lazily on first body chunk with more_body=True.
     writer = None
+    writer_closed = False
 
     receive_queue = Queue()
     if req.body:
@@ -208,6 +216,7 @@ async def process_request(
         nonlocal status
         nonlocal headers
         nonlocal writer
+        nonlocal writer_closed
 
         if got["type"] == "http.response.start":
             status = got["status"]
@@ -224,6 +233,7 @@ async def process_request(
                     await writer.write(jsbytes.slice())
                 if not more_body:
                     await writer.close()
+                    writer_closed = True
                     finished_response.set()
             elif more_body:
                 # First body chunk with more data coming — switch to streaming.
@@ -275,6 +285,15 @@ async def process_request(
                 # Response already sent — exception can't be propagated to the
                 # client, so log it to avoid silently swallowing errors.
                 logger.exception("Exception in ASGI application after response started")
+                finished_response.set()
+                if writer is not None and not writer_closed:
+                    # End the body so a client reading it sees the stream stop
+                    # instead of waiting forever for chunks that will never
+                    # come. Deliberately not awaited: close() settles only once
+                    # the queued chunks reach a consumer, so a response body
+                    # that nobody reads would block this task, which the
+                    # 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()))

workers_runtime_sdk-1.6.11/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.11/tests/web-frameworks-test/fastapi-tests/src/static/data.json

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

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

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

workers_runtime_sdk-1.6.11/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.11/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.9 → workers_runtime_sdk-1.6.11}/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.11/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.9 → workers_runtime_sdk-1.6.11}/tests/workerd-test/asgi/tests/test_asgi.py

@@ -399,3 +399,16 @@ async def test_scope_path_is_percent_decoded():
 async def test_scope_exposes_raw_path():
     scope = await _scope("/scope/hello%20world")
     assert scope["raw_path"] == "/scope/hello%20world"
+
+
+@pytest.mark.asyncio
+async def test_late_stream_failure_terminates_response():
+    # An app that raises after the streaming response started must terminate
+    # the stream (truncated EOF) instead of leaving the client hanging; a
+    # regression here surfaces as a timeout or workerd's hung-request
+    # cancellation instead of a clean read.
+    response = await asyncio.wait_for(
+        env.SELF.fetch("http://example.com/stream-late-failure"), timeout=5
+    )
+    body = await asyncio.wait_for(response.text(), timeout=5)
+    assert body == "chunk-1"

{workers_runtime_sdk-1.6.9 → workers_runtime_sdk-1.6.11}/tests/workerd-test/asgi/worker.py

@@ -182,6 +182,29 @@ class StreamingApp:
 # ---------------------------------------------------------------------------
 
 
+class LateFailureStreamApp:
+    """Starts a streaming response, then raises: the stream must terminate."""
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await send({"type": "lifespan.startup.complete"})
+            return
+        await receive()
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"application/octet-stream")],
+            }
+        )
+        await send(
+            {"type": "http.response.body", "body": b"chunk-1", "more_body": True}
+        )
+        raise RuntimeError("app failed mid-stream")
+
+
 class ScopeEchoApp:
     """Echoes selected scope fields as JSON so tests can inspect them."""
 
@@ -214,6 +237,7 @@ app = HeaderEchoApp()
 sse_app = SSEApp()
 streaming_app = StreamingApp()
 scope_echo_app = ScopeEchoApp()
+late_failure_stream_app = LateFailureStreamApp()
 
 example_hdr = {"Header1": "Value1", "Header2": "Value2"}
 
@@ -231,6 +255,10 @@ class Default(WorkerEntrypoint):
             return await asgi.fetch(streaming_app, request, self.env, self.ctx)
         elif path.startswith("/scope"):
             return await asgi.fetch(scope_echo_app, request, self.env, self.ctx)
+        elif path == "/stream-late-failure":
+            return await asgi.fetch(
+                late_failure_stream_app, request, self.env, self.ctx
+            )
 
         return await asgi.fetch(app, request, self.env, self.ctx)
 

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

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

workers_runtime_sdk-1.6.9/src/_workers_sdk_entropy_import_context.pth

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

workers_runtime_sdk-1.6.9/src/_workers_sdk_entropy_import_context_loader.py

@@ -1,13 +0,0 @@
-"""
-Loader shim for _workers_sdk_entropy_import_context.
-
-This module is imported by the .pth file on every Python startup. The entropy
-context 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.
-"""
-
-import importlib.util
-
-if importlib.util.find_spec("_cloudflare") is not None:
-    import _workers_sdk_entropy_import_context  # noqa: F401

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

@@ -1,11 +0,0 @@
-{
-    "name": "fastapi-tests",
-    "main": "src/worker.py",
-    "compatibility_date": "%COMPAT_DATE",
-    "compatibility_flags": ["python_workers"],
-    "assets": {
-        "directory": "./public/",
-        "binding": "ASSETS",
-        "run_worker_first": true
-    }
-}