workers-runtime-sdk 1.8.6__tar.gz → 1.9.1__tar.gz

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 <!-- version list -->
 
+## v1.9.1 (2026-09-29)
+
+### Bug Fixes
+
+- **runtime-sdk**: Add rpds to rust package entropy context
+  ([#277](https://github.com/cloudflare/workers-py/pull/277),
+  [`a097b7c`](https://github.com/cloudflare/workers-py/commit/a097b7c5d2e5bba17f34d46abb6e39039d4673d4))
+
+
+## v1.9.0 (2026-09-18)
+
+### Bug Fixes
+
+- **runtime-sdk**: Make NonRetryableError raised in a workflow step non-retryable
+  ([`1c1980a`](https://github.com/cloudflare/workers-py/commit/1c1980afabaa27d39bf18d3fe19c7385c2890fa6))
+
+### Features
+
+- **runtime-sdk**: Add helpers to import JavaScript modules shipped with the SDK
+  ([`caa9364`](https://github.com/cloudflare/workers-py/commit/caa9364f38a111d5496f81f6bc23ebb88d191928))
+
+
 ## v1.8.6 (2026-09-18)
 
 ### Bug Fixes

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/PKG-INFO

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

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

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/src/_workers_sdk_entropy_import_context.py

@@ -49,6 +49,7 @@ class STATE:
 @register_create_patch("tiktoken._tiktoken")
 @register_exec_patch("cryptography.exceptions")
 @register_exec_patch("jiter")
+@register_exec_patch("rpds")
 @register_exec_patch("uuid_utils._uuid_utils")
 @contextmanager
 def rust_package_context(module):

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/src/workers/entrypoints.py

@@ -17,7 +17,11 @@ from .rpc import (
     python_from_rpc,
     python_to_rpc,
 )
-from .utils import _from_js_error, _is_js_instance
+from .utils import (
+    _from_js_error,
+    _is_js_instance,
+    import_sdk_javascript_module_async,
+)
 
 if TYPE_CHECKING:
     from js import DurableObjectState, Env, ExecutionContext
@@ -294,6 +298,22 @@ def _wrap_class(cls):
     return cls
 
 
+_workflows_js_module = None
+
+
+async def _wrap_js_workflow_step(js_step):
+    """
+    Wrap the JS `WorkflowStep` stub with `wrapWorkflowStep` from the SDK's `workflows.js`.
+
+    The wrapper makes a Python `NonRetryableError` raised inside a step reach the Workflows
+    engine as a JS error the engine recognises as non-retryable (see `workflows.js`).
+    """
+    global _workflows_js_module  # noqa: PLW0603
+    if _workflows_js_module is None:
+        _workflows_js_module = await import_sdk_javascript_module_async("workflows.js")
+    return _workflows_js_module.wrapWorkflowStep(js_step)
+
+
 def _wrap_workflow_step(cls):
     run_fn = cls.__dict__.get("run")
     if run_fn is None:
@@ -304,7 +324,7 @@ def _wrap_workflow_step(cls):
         if event is not None:
             event = python_from_rpc(event)
         if step is not None:
-            step = _WorkflowStepWrapper(step)
+            step = _WorkflowStepWrapper(await _wrap_js_workflow_step(step))
 
         result = run_fn(self, event, step, *args, **kwargs)
 

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/src/workers/utils.py

@@ -126,6 +126,25 @@ def import_from_javascript(module_name: str) -> Any:
         raise
 
 
+# Directory, relative to the worker bundle root, that `pywrangler sync` vendors Python packages
+# into. wrangler registers `.js`/`.mjs` files found under `python_modules/workers/` as ES modules
+# (everything else in `python_modules/` is opaque data), which is what lets them be imported via
+# `import_from_javascript`.
+_SDK_JS_MODULE_PREFIX = "python_modules/workers/"
+
+
+async def import_sdk_javascript_module_async(name: str) -> Any:
+    """
+    Asynchronous function to import an sdk js module
+
+    This does not rely on JSPI, so it also works with Pyodide 0.26.0a2.
+    """
+    try:
+        return await _pyodide_entrypoint_helper.doAnImport(_SDK_JS_MODULE_PREFIX + name)
+    except JsException as e:
+        raise ImportError(f"Failed to import '{name}': {e}") from e
+
+
 @contextmanager
 def patch_env(
     d: dict[str, Any] | Sequence[tuple[str, Any]] | None = None, **kwds: dict[str, Any]
@@ -144,15 +163,30 @@ def _to_python_exception(exc: JsException) -> Exception:
         return exc
 
 
+_NON_RETRYABLE_ERROR_NAME = "NonRetryableError"
+
+
 def _from_js_error(exc: JsException) -> Exception:
     # convert into Python exception after a full round trip
     # Python - JS - Python
     message = exc.message or ""
 
+    # A NonRetryableError raised inside a workflow step is translated by the
+    # runtime into a JS error named "NonRetryableError" before it reaches the
+    # Workflows engine, which is how the engine knows not to retry the step.
+    # When the engine rethrows it back to us the name either survives, or is
+    # folded into the message as a prefix.
+    if getattr(exc, "name", None) == _NON_RETRYABLE_ERROR_NAME:
+        return NonRetryableError(message)
+    if message == _NON_RETRYABLE_ERROR_NAME:
+        return NonRetryableError()
+    if message.startswith(_NON_RETRYABLE_ERROR_NAME + ": "):
+        return NonRetryableError(message[len(_NON_RETRYABLE_ERROR_NAME) + 2 :])
+
     # A Python exception that escaped to JS is a Pyodide `PythonError` whose
     # message is the formatted traceback. Depending on how it was serialized
     # over RPC it either keeps its name or arrives as a plain `Error` with
-    # "PythonError: " folded into the message.
+    # "PythonError: " folded into the message
     if getattr(exc, "name", None) != "PythonError" and not message.startswith(
         "PythonError"
     ):

workers_runtime_sdk-1.9.1/src/workers/workflows.js

@@ -0,0 +1,91 @@
+// JavaScript helpers for Python Workflows
+
+const NON_RETRYABLE_ERROR_NAME = "NonRetryableError";
+
+function isPythonError(e) {
+  return (
+    e instanceof Error &&
+    e.constructor?.name === "PythonError" &&
+    typeof e.type === "string"
+  );
+}
+
+// Extract the message the user passed to the Python exception from the
+// traceback stored in `PythonError.message`.
+//
+// The last non-empty line of a formatted traceback is
+// `<qualified.ExceptionType>: <message>`, or just `<qualified.ExceptionType>`
+// when the exception was raised without a message. For example, given
+//
+//   Traceback (most recent call last):
+//     File "/session/metadata/worker.py", line 19, in non_retryable
+//       raise NonRetryableError("do not retry")
+//   workers.workflows.NonRetryableError: do not retry
+//
+// this returns "do not retry", and given
+//
+//   Traceback (most recent call last):
+//     File "/session/metadata/worker.py", line 34, in no_message
+//       raise NonRetryableError()
+//   workers.workflows.NonRetryableError
+//
+// it returns "".
+function pythonExceptionMessage(e) {
+  const lines = e.message.split("\n").filter((line) => line.trim() !== "");
+  const last = lines.at(-1) ?? "";
+  const sep = last.indexOf(": ");
+  return sep === -1 ? "" : last.slice(sep + 2);
+}
+
+// Wraps a Python step callback passed to `WorkflowStep.do()`.
+//
+// If the error thrown is a Python NonRetryable error, translate it into a JS
+// error that the engine will recognize as non retryable. Leave other errors
+// alone.
+export function wrapWorkflowStepCallback(pyCallback) {
+  return async function (...args) {
+    try {
+      return await pyCallback(...args);
+    } catch (e) {
+      if (isPythonError(e) && e.type === NON_RETRYABLE_ERROR_NAME) {
+        const err = new Error(pythonExceptionMessage(e));
+        err.name = NON_RETRYABLE_ERROR_NAME;
+        throw err;
+      }
+      throw e;
+    }
+  };
+}
+
+// Wraps the `WorkflowStep` RPC stub passed to a Python
+// `WorkflowEntrypoint.run()` so that the callback given to `step.do()` goes
+// through `wrapWorkflowStepCallback`.
+//
+// Because the wrapped `do` returns the stub's own promise, a Python callback
+// passed to it keeps exactly the lifetime it would have had without the
+// wrapper.
+export function wrapWorkflowStep(step) {
+  // RPC stubs are callable, so `typeof step` is 'function'.
+  if (
+    step === null ||
+    (typeof step !== "object" && typeof step !== "function")
+  ) {
+    return step;
+  }
+  return new Proxy(step, {
+    apply(target, thisArg, args) {
+      return Reflect.apply(target, thisArg, args);
+    },
+    get(target, prop) {
+      if (prop !== "do") {
+        return Reflect.get(target, prop);
+      }
+      return function (name, ...rest) {
+        const args = rest.map((arg) =>
+          typeof arg === "function" ? wrapWorkflowStepCallback(arg) : arg
+        );
+        return target.do(name, ...args);
+      };
+    },
+  });
+}

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/bindings-test/pyproject.toml

@@ -7,13 +7,18 @@ dependencies = [
     "pytest-asyncio<1.2.0",
     # These are for hyperdrive tests
     "pg8000",
-    "pymysql",
+    # There is a regression in upstream pymysql.
+    # Remove when the following PR is merged and released.
+    # https://github.com/PyMySQL/PyMySQL/pull/1275
+    "pymysql<=1.2.0",
     "aiomysql",
     "psycopg[binary]; python_version >= '3.14'",
     "asyncpg; python_version >= '3.14'",
     "cryptography",
     "testlib",
+    "workers-runtime-sdk",
 ]
 
 [tool.uv.sources]
-testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/bindings-test/src/test_workflow.py

@@ -149,7 +149,17 @@ async def test_step_retry_config(env):
 async def test_non_retryable_error(env):
     instance = await env.MY_WORKFLOW.create({"params": {"mode": "non_retryable"}})
     status = await _poll(instance)
-    assert status["status"] == "errored", f"unexpected status: {dict(status)!r}"
+    assert status["status"] == "complete", f"unexpected status: {dict(status)!r}"
+    out = status["output"]
+    # The step would succeed on attempt 2, so `retried` means the engine ignored
+    # the NonRetryableError.
+    assert out["retried"] is False, f"step was retried: {out!r}"
+    # ...and the error must come back to `run()` as a Python NonRetryableError.
+    assert out["caught"] == "NonRetryableError", out
+    # The message is preserved end to end in workerd, but miniflare currently
+    # truncates error messages crossing from the Python worker into its
+    # Workflows engine at the first ": " so accept an empty message here.
+    assert out["message"] in ("do not retry", ""), out
 
 
 async def test_error_handling_catch(env):

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/bindings-test/src/worker_workflow.py

@@ -109,14 +109,30 @@ class TestWorkflow(WorkflowEntrypoint):
         return await flaky()
 
     async def _non_retryable(self, event, step):
+        # Fails on the first attempt with NonRetryableError and would succeed on a
+        # second attempt. If the engine honours NonRetryableError the step fails
+        # once and `run()` sees a NonRetryableError; if the engine retries, the step
+        # completes with `attempt == 2`.
         @step.do(
             "non-retryable-step",
-            config={"retries": {"limit": 1, "delay": 0, "backoff": "constant"}},
+            config={"retries": {"limit": 3, "delay": 0, "backoff": "constant"}},
         )
-        async def boom():
-            raise NonRetryableError("do not retry")
+        async def boom(ctx):
+            if int(ctx["attempt"]) < 2:
+                raise NonRetryableError("do not retry")
+            return {"retried": True, "attempt": int(ctx["attempt"])}
 
-        return await boom()
+        try:
+            result = await boom()
+        except NonRetryableError as exc:
+            return {
+                "retried": False,
+                "caught": "NonRetryableError",
+                "message": str(exc),
+            }
+        except Exception as exc:
+            return {"retried": False, "caught": type(exc).__name__, "message": str(exc)}
+        return result
 
     async def _duplicate_step_names(self, event, step):
         # The engine disambiguates repeated step names with a counter, so two

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/conftest.py

@@ -2,7 +2,6 @@
 
 import os
 import shutil
-import subprocess
 from collections.abc import Generator
 from pathlib import Path
 from typing import Any
@@ -12,6 +11,8 @@ from testlib.host import (
     COMPAT_CONFIGS,
     CompatConfig,
     configure_compatibility,
+    link_packages,
+    pywrangler_sync,
 )
 from testlib.host import (
     dev_server as run_dev_server,
@@ -21,9 +22,6 @@ from testlib.host import (
 )
 
 TEST_DIR: Path = Path(__file__).parent
-WORKERS_PY: Path = TEST_DIR.parent.parent / "cli"
-WORKERS_RUNTIME_SDK: Path = TEST_DIR.parent / "src"
-TESTLIB: Path = TEST_DIR.parent.parent / "testlib"
 
 DEV_STARTUP_TIMEOUT: int = 120
 OPT_IN_MARKERS: tuple[str, ...] = ("hyperdrive",)
@@ -43,11 +41,6 @@ def pytest_collection_modifyitems(
                 item.add_marker(skip)
 
 
-@pytest.fixture(scope="session", autouse=True)
-def build_testlib():
-    subprocess.run(["uv", "build"], cwd=TESTLIB, check=True)
-
-
 @pytest.fixture(
     scope="module",
     params=COMPAT_CONFIGS,
@@ -74,32 +67,27 @@ def dev_server(
     worker_project_dir: Path,
     compat_config: CompatConfig,
 ) -> Generator[str]:
-    """Start a pywrangler dev server on a free port and yield its base URL."""
+    """Start a pywrangler dev server on a free port and yield its base URL.
+
+    The project is copied next to a ``packages`` symlink so that its
+    ``../packages/...`` sources resolve and ``sync`` vendors the working-tree
+    testlib and runtime-sdk.
+    """
     tmp_path = tmp_path_factory.mktemp(f"{worker_project_dir.name}_dev")
     target = tmp_path / worker_project_dir.name
     shutil.copytree(worker_project_dir, target, ignore=shutil.ignore_patterns(".venv"))
-    shutil.copytree(TESTLIB, tmp_path / "testlib")
+    link_packages(tmp_path)
     env = os.environ | {"_PYODIDE_EXTRA_MOUNTS": str(tmp_path)}
 
     wrangler_jsonc = target / "wrangler.jsonc"
     configure_compatibility(wrangler_jsonc, compat_config)
 
-    pywrangler_cmd = ["uv", "run", "--no-project", "--with", WORKERS_PY, "pywrangler"]
-
-    subprocess.run(
-        [*pywrangler_cmd, "sync"],
-        cwd=target,
-        check=True,
-        env=env,
-    )
-
-    shutil.copytree(WORKERS_RUNTIME_SDK, target / "python_modules", dirs_exist_ok=True)
+    pywrangler_sync(target, env)
 
     with run_dev_server(
         target,
         tmp_path,
         env,
-        pywrangler_cmd,
         startup_timeout=DEV_STARTUP_TIMEOUT,
         readiness_path="/health",
         require_success=True,
@@ -113,4 +101,4 @@ def register_in_worker_suites(
     src_dir: Path,
     marks: dict[str, pytest.MarkDecorator] | None = None,
 ) -> None:
-    register_testlib_suites(namespace, src_dir, marks=marks, class_name=str.upper)
+    register_testlib_suites(namespace, src_dir, marks=marks)

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/test_in_workerd.py

@@ -8,12 +8,12 @@ from conftest import (
     COMPAT_CONFIGS,
     CompatConfig,
     configure_compatibility,
+    link_packages,
+    pywrangler_sync,
 )
 
 TEST_DIR = Path(__file__).parent
 WORKERD_TESTS = TEST_DIR / "workerd-test"
-WORKERS_PY = TEST_DIR.parent.parent / "cli"
-WORKERS_RUNTIME_SDK = TEST_DIR.parent / "src"
 DISK_SERVICE_NAME = "TEST_TMPDIR"
 
 
@@ -66,14 +66,27 @@ def embed(dir: Path, root: Path, level: int = 0):
         module_path = path.absolute().relative_to(module_path_root)
         embed_path = path.absolute().relative_to(root)
         if path.suffix == ".py":
-            modules.append(
-                f'(name = "{module_path}", pythonModule = embed "{embed_path}")'
-            )
+            module_type = "pythonModule"
+        elif _is_sdk_js_module(path.relative_to(dir)):
+            module_type = "esModule"
         else:
-            modules.append(f'(name = "{module_path}", data = embed "{embed_path}")')
+            module_type = "data"
+        modules.append(
+            f'(name = "{module_path}", {module_type} = embed "{embed_path}")'
+        )
     return modules
 
 
+def _is_sdk_js_module(path_in_vendor_dir: Path) -> bool:
+    """Mirror wrangler: `.js`/`.mjs` files under `python_modules/workers/` are ES modules.
+
+    Other vendored packages may ship `.js` assets that are not valid ES modules, so wrangler
+    only applies this rule to the SDK's own `workers/` package. Everything else stays `data`.
+    """
+    in_sdk_package = path_in_vendor_dir.parts[:1] == ("workers",)
+    return in_sdk_package and path_in_vendor_dir.suffix in (".js", ".mjs")
+
+
 @pytest.fixture(scope="module")
 def bundle_cache_dir(tmp_path_factory):
     yield tmp_path_factory.mktemp("bundle_cache")
@@ -110,23 +123,14 @@ def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
     target = tmp_path / test_dir.name
     disk_service_dir = target / DISK_SERVICE_NAME
     shutil.copytree(test_dir, target, ignore=shutil.ignore_patterns(".venv"))
+    # Makes the project's `../packages/{runtime-sdk,testlib}` sources resolve
+    # so `sync` vendors the working-tree SDK and testlib.
+    link_packages(tmp_path)
     disk_service_dir.mkdir(exist_ok=True)
 
     configure_compatibility(target / "wrangler.jsonc", compat_config)
 
-    pywrangler_cmd = ["uv", "run", "--no-project", "--with", WORKERS_PY, "pywrangler"]
-
-    subprocess.run(
-        [*pywrangler_cmd, "sync"],
-        cwd=target,
-        check=True,
-        env=os.environ | {"_PYODIDE_EXTRA_MOUNTS": str(tmp_path)},
-    )
-
-    # Copy runtime-sdk to the python modules as well
-    # FIXME: remove this and pass runtime-sdk as a dependency explicitly after
-    #        https://github.com/cloudflare/workers-py/pull/81 is merged
-    shutil.copytree(WORKERS_RUNTIME_SDK, target / "python_modules", dirs_exist_ok=True)
+    pywrangler_sync(target, os.environ | {"_PYODIDE_EXTRA_MOUNTS": str(tmp_path)})
 
     modules = embed(target / "python_modules", target, level=1) + embed(
         target / "tests", target, level=1

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/web-frameworks-test/django-async/pyproject.toml

@@ -11,7 +11,9 @@ dependencies = [
     "pytest",
     "pytest-asyncio<1.2.0",
     "testlib",
+    "workers-runtime-sdk",
 ]
 
 [tool.uv.sources]
-testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/web-frameworks-test/fastapi-tests/pyproject.toml

@@ -8,7 +8,9 @@ dependencies = [
     "pytest",
     "pytest-asyncio<1.2.0",
     "testlib",
+    "workers-runtime-sdk",
 ]
 
 [tool.uv.sources]
-testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -30,21 +30,12 @@ from fastapi.responses import (
 from fastapi.responses import Response as FastAPIResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
-from pyodide.webloop import WebLoop
 from starlette.background import BackgroundTask
 from starlette.middleware.gzip import GZipMiddleware
-from testlib.entrypoint import TestRunner
+from testlib.entrypoint import RunSuiteRequest, TestRunner
 
 import asgi
 
-
-async def _noop(*args):
-    pass
-
-
-WebLoop.shutdown_asyncgens = _noop
-WebLoop.shutdown_default_executor = _noop
-
 STATIC_DIR = Path(__file__).parent / "static"
 
 
@@ -603,7 +594,9 @@ class FastAPIAppPlugin:
 @app.get("/run-tests/{suite_name:path}")
 async def run_suite(suite_name: str, request: Request):
     runner = TestRunner(request.scope["env"], extra_plugins=[FastAPIAppPlugin()])
-    result = runner.run_suite(suite_name)
+    result = runner.run_suite(
+        suite_name, RunSuiteRequest.from_query_params(request.query_params)
+    )
     return JSONResponse(result.payload, status_code=result.status)
 
 

workers_runtime_sdk-1.9.1/tests/web-frameworks-test/flask-tests/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "flask-tests"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["flask", "pytest", "testlib", "workers-runtime-sdk"]
+
+[tool.uv.sources]
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

workers_runtime_sdk-1.9.1/tests/workerd-test/asgi/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "test"
+version = "0.0.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0", "testlib", "workers-runtime-sdk"]
+
+[tool.uv.sources]
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/workerd-test/asgi/worker.py

@@ -1,28 +1,10 @@
-import asyncio
 import os
-import sys
 
-import pytest
-from pyodide.webloop import WebLoop
+from testlib.entrypoint import run_pytest
 
 import asgi
 from workers import WorkerEntrypoint
 
-
-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.
-if sys.version_info < (3, 13):
-    asyncio.runners._cancel_all_tasks = lambda loop: None  # type: ignore[attr-defined]
-
-
 # ---------------------------------------------------------------------------
 # ASGI apps
 # ---------------------------------------------------------------------------
@@ -291,4 +273,4 @@ class Default(WorkerEntrypoint):
     async def test(self):
         os.chdir("/session/metadata/tests")
         args = [".", "-vv"]
-        assert pytest.main(args) == 0
+        run_pytest(args)

workers_runtime_sdk-1.9.1/tests/workerd-test/asgi-ws-disconnect/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "test"
+version = "0.0.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0", "testlib", "workers-runtime-sdk"]
+
+[tool.uv.sources]
+testlib = { path = "../packages/testlib" }
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }

{workers_runtime_sdk-1.8.6 → workers_runtime_sdk-1.9.1}/tests/workerd-test/asgi-ws-disconnect/worker.py

@@ -1,29 +1,12 @@
-import asyncio
 import os
-import sys
 from urllib.parse import urlsplit
 
-import pytest
-from pyodide.webloop import WebLoop
+from testlib.entrypoint import run_pytest
 
 import asgi
 from workers import WorkerEntrypoint
 
 
-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.
-if sys.version_info < (3, 13):
-    asyncio.runners._cancel_all_tasks = lambda loop: None  # type: ignore[attr-defined]
-
-
 async def _drain_lifespan(receive, send):
     message = await receive()
     if message["type"] == "lifespan.startup":
@@ -180,4 +163,4 @@ class Default(WorkerEntrypoint):
     async def test(self):
         os.chdir("/session/metadata/tests")
         args = [".", "-vv"]
-        assert pytest.main(args) == 0
+        run_pytest(args)

workers_runtime_sdk-1.9.1/tests/workerd-test/durable-object/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "test"
+version = "0.0.0"
+requires-python = ">=3.12"
+dependencies = ["workers-runtime-sdk"]
+
+[tool.uv.sources]
+workers-runtime-sdk = { path = "../packages/runtime-sdk" }