workers-runtime-sdk 1.8.2__tar.gz → 1.8.5__tar.gz

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 <!-- version list -->
 
+## v1.8.5 (2026-09-17)
+
+### Bug Fixes
+
+- **runtime-sdk**: Fix top-level import for opentelemetry package
+  ([#248](https://github.com/cloudflare/workers-py/pull/248),
+  [`338c12e`](https://github.com/cloudflare/workers-py/commit/338c12e5dc6aada9dd20968fdae6bb6e805ad33e))
+
+
+## v1.8.4 (2026-09-08)
+
+### Bug Fixes
+
+- **runtime-sdk**: Fix top-level entropy call for litestar and fix entropy tests
+  ([#241](https://github.com/cloudflare/workers-py/pull/241),
+  [`99b77c7`](https://github.com/cloudflare/workers-py/commit/99b77c7658d1e4b0591233b8ce6cc179719751e3))
+
+
+## v1.8.3 (2026-08-31)
+
+### Bug Fixes
+
+- **runtime-sdk**: Stop losing details of ASGI lifespan failures
+  ([#172](https://github.com/cloudflare/workers-py/pull/172),
+  [`c6d1f69`](https://github.com/cloudflare/workers-py/commit/c6d1f69e96fd13b5b9e41f48e70aebb7469310c8))
+
+
 ## v1.8.2 (2026-08-31)
 
 ### Bug Fixes

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.8.2"
+version = "1.8.5"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -21,42 +21,18 @@ dev = [
   "ruff>=0.1.0",
   "mypy>=1.0.0",
   "requests>=2.28.0",
+  "testlib[host]",
 ]
 
+[tool.uv.sources]
+testlib = { path = "../testlib", editable = true }
+
 [project.urls]
 "Homepage" = "https://github.com/cloudflare/workers-py"
 "Bug Tracker" = "https://github.com/cloudflare/workers-py/issues"
 
 [tool.ruff]
-target-version = "py311"
-lint.select = [
-  "B0",     # bugbear (all B0* checks enabled by default)
-  "B904",   # bugbear (Within an except clause, raise exceptions with raise ... from err)
-  "B905",   # bugbear (zip() without an explicit strict= parameter set.)
-  "C4",     # flake8-comprehensions
-  "C9",     # mccabe complexity
-  "E",      # pycodestyles
-  "F",      # pyflakes
-  "I",      # isort
-  "PERF",   # Perflint
-  "PGH",    # pygrep-hooks
-  "PL",     # Pylint
-  "UP",     # pyupgrade
-  "W",      # pycodestyles
-]
-lint.ignore = [
-  "C901", # Too complex
-  "E402",
-  "E501",
-  "E731",
-  "E741",
-  "PLR0911", # Too many return statements
-  "PLR0915", # Too many statements
-  "PLW2901",
-  "UP031",
-  "UP038", # Use X | Y instead of (X, Y)
-]
-lint.flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
+extend = "../../ruff.toml"
 lint.per-file-ignores."tests/**" = ["PLR2004", "PLR0913"]
 lint.per-file-ignores."tests/workerd-test/**" = ["C901", "PLR0911", "PLR0912", "PLR2004", "PLW0603"]
 lint.per-file-ignores."tests/bindings-test/**" = ["C901", "PLR0911", "PLR0912", "PLR2004", "PLW0603"]

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/src/_workers_sdk_entropy_import_context.py

@@ -4,6 +4,7 @@ Top level entropy patches for packages
 
 import sys
 from contextlib import contextmanager
+from importlib.metadata import PackageNotFoundError, version
 
 from _cloudflare.allow_entropy import (
     allow_bad_entropy_calls,
@@ -17,6 +18,29 @@ from _cloudflare.import_patch_manager import (
 )
 
 
+@contextmanager
+def allow_bad_entropy_calls_for_version(
+    package_name: str,
+    num_calls: int,
+    min_version: tuple[int, ...],
+    max_version: tuple[int, ...] | None = None,
+):
+    try:
+        package_version = tuple(map(int, version(package_name).split(".")))
+    except PackageNotFoundError:
+        yield
+        return
+
+    if package_version < min_version or (
+        max_version is not None and package_version > max_version
+    ):
+        yield
+        return
+
+    with allow_bad_entropy_calls(num_calls):
+        yield
+
+
 class STATE:
     imported_rust_package = False
     numpy_random = None
@@ -178,3 +202,38 @@ def langsmith__internal__constants_context(module):
 def langchain_openai_chat_models_base_context(module):
     with allow_bad_entropy_calls(1):
         yield
+
+
+@register_exec_patch("opentelemetry.context")
+@contextmanager
+def opentelemetry_context(module):
+    # OpenTelemetry creates three UUID-backed keys.
+    with allow_bad_entropy_calls_for_version("opentelemetry-api", 3, (1, 40, 0)):
+        yield
+
+
+@register_exec_patch("opentelemetry.trace.propagation")
+@contextmanager
+def opentelemetry_trace_propagation_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("opentelemetry.baggage")
+@contextmanager
+def opentelemetry_baggage_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("litestar.openapi.controller")
+@register_exec_patch("litestar.constants")
+@contextmanager
+def litestar_context(module):
+    # Uses os.urandom() to generate a OPENAPI_JSON_HANDLER_NAME
+    # https://github.com/litestar-org/litestar/blob/e3b6a1d103a9160a575dce01ae34839e6e9bf990/litestar/constants.py#L19
+    # https://github.com/litestar-org/litestar/blob/v2.24.0/litestar/openapi/controller.py#L27
+    with allow_bad_entropy_calls(1):
+        yield

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/src/workers/asgi.py

@@ -127,7 +127,9 @@ async def start_application(app):
                 startup.set_result(True)
             return
         if got["type"] == "lifespan.startup.failed":
-            message = got.get("message", "ASGI lifespan startup failed")
+            # `or`, not a .get default: an empty message field is legal and
+            # would otherwise produce RuntimeError('').
+            message = got.get("message") or "ASGI lifespan startup failed"
             if not startup.done():
                 startup.set_exception(RuntimeError(message))
             return
@@ -136,7 +138,7 @@ async def start_application(app):
                 shutdown_complete.set_result(None)
             return
         if got["type"] == "lifespan.shutdown.failed":
-            message = got.get("message", "ASGI lifespan shutdown failed")
+            message = got.get("message") or "ASGI lifespan shutdown failed"
             if not shutdown_complete.done():
                 shutdown_complete.set_exception(RuntimeError(message))
             return
@@ -161,8 +163,15 @@ async def start_application(app):
                 shutdown_complete.set_result(None)
         except Exception as exc:
             # Spec: an exception raised before startup is acked signals that the
-            # app doesn't support lifespan; swallow it and serve requests anyway.
+            # app doesn't support lifespan; serve requests anyway. Log it, or an
+            # app that crashed mid-startup looks like one with no lifespan
+            # handler at all.
             if not startup.done():
+                logger.debug(
+                    "ASGI lifespan task raised before reporting startup; "
+                    "treating the app as not supporting lifespan",
+                    exc_info=exc,
+                )
                 startup.set_result(False)
                 return
             # After a successful startup, a shutdown-phase error can't affect the

workers_runtime_sdk-1.8.5/tests/bindings-test/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "bindings-test"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "pytest",
+    "pytest-asyncio<1.2.0",
+    # These are for hyperdrive tests
+    "pg8000",
+    "pymysql",
+    "aiomysql",
+    "psycopg[binary]; python_version >= '3.14'",
+    "asyncpg; python_version >= '3.14'",
+    "cryptography",
+    "testlib",
+]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/tests/bindings-test/src/test_hyperdrive_mysql.py

@@ -24,6 +24,7 @@ uv run pytest tests/test_bindings.py -m hyperdrive -k mysql
 
 import sys
 
+import aiomysql
 import pymysql
 import pytest
 from conftest import unique_table_name
@@ -58,6 +59,26 @@ async def test_connect(env):
     conn.close()
 
 
+@pytest.mark.asyncio
+async def test_connect_aiomysql(env):
+    hd = env.HYPERDRIVE_MYSQL
+    conn = await aiomysql.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        db=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl=None,
+    )
+    try:
+        async with conn.cursor() as cur:
+            await cur.execute("SELECT %s", (1,))
+            assert await cur.fetchone() == (1,)
+    finally:
+        await conn.ensure_closed()
+
+
 @pytest.mark.asyncio
 async def test_create_insert_select(env):
     conn = _connect(env)

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/tests/bindings-test/src/test_hyperdrive_postgresql.py

@@ -61,6 +61,71 @@ async def test_connect(env):
     conn.close()
 
 
+@pytest.mark.asyncio
+async def test_connect_psycopg(env):
+    import psycopg  # noqa: PLC0415
+
+    assert psycopg.pq.__impl__ == "binary"
+    hd = env.HYPERDRIVE_PG
+    with psycopg.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        dbname=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        sslmode="disable",
+    ) as conn:
+        with conn.cursor() as cur:
+            cur.execute("SELECT %s", (1,))
+            assert cur.fetchone() == (1,)
+
+
+@pytest.mark.asyncio
+async def test_asyncpg_crud(env):
+    import asyncpg  # noqa: PLC0415
+
+    hd = env.HYPERDRIVE_PG
+    conn = await asyncpg.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl=False,
+    )
+    table = unique_table_name()
+    try:
+        await conn.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        await conn.execute(
+            f"INSERT INTO {table} (name, value) VALUES ($1, $2)", "alpha", 1
+        )
+
+        row = await conn.fetchrow(
+            f"SELECT name, value FROM {table} WHERE name = $1", "alpha"
+        )
+        assert tuple(row) == ("alpha", 1)
+
+        await conn.execute(
+            f"UPDATE {table} SET value = $1 WHERE name = $2", 11, "alpha"
+        )
+        assert (
+            await conn.fetchval(f"SELECT value FROM {table} WHERE name = $1", "alpha")
+            == 11
+        )
+
+        await conn.execute(f"DELETE FROM {table} WHERE name = $1", "alpha")
+        assert await conn.fetchval(f"SELECT COUNT(*) FROM {table}") == 0
+    finally:
+        try:
+            await conn.execute(f"DROP TABLE IF EXISTS {table}")
+        finally:
+            await conn.close()
+
+
 @pytest.mark.asyncio
 async def test_create_insert_select(env):
     conn = _connect(env)

workers_runtime_sdk-1.8.5/tests/bindings-test/src/worker.py

@@ -0,0 +1,32 @@
+"""Bindings test worker.
+
+Each binding suite lives in a `test_<suite>.py` module written as ordinary pytest
+tests (see test_kv.py). The `/run-tests/<suite>` endpoint runs pytest against that
+module inside workerd and returns per-test results as JSON, which the host-side
+test_bindings.py maps onto individual pytest cases.
+
+To add a new binding: create `src/test_<binding>.py` with pytest tests.
+"""
+
+from testlib.entrypoint import TestRunnerEntrypoint
+from worker_durable_object import (
+    TestDurableObject,  # noqa: F401 - import to trigger side effect of registering the Durable Object
+)
+from worker_workflow import (
+    TestWorkflow,  # noqa: F401 - import to trigger side effect of registering the Workflow
+)
+
+RECEIVED_MESSAGES = []
+
+
+class Default(TestRunnerEntrypoint):
+    async def queue(self, batch, env, ctx):
+        for message in batch.messages:
+            RECEIVED_MESSAGES.append(
+                {
+                    "id": message.id,
+                    "body": message.body,
+                    "attempts": message.attempts,
+                }
+            )
+            message.ack()

workers_runtime_sdk-1.8.5/tests/conftest.py

@@ -0,0 +1,116 @@
+"""Shared fixtures and helpers for the host-side test suite."""
+
+import os
+import shutil
+import subprocess
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+
+import pytest
+from testlib.host import (
+    COMPAT_CONFIGS,
+    CompatConfig,
+    configure_compatibility,
+)
+from testlib.host import (
+    dev_server as run_dev_server,
+)
+from testlib.host import (
+    register_in_worker_suites as register_testlib_suites,
+)
+
+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",)
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    """Skip opt-in suites unless the run explicitly asks for them via ``-m``."""
+    markexpr: str = config.getoption("markexpr")
+    for marker in OPT_IN_MARKERS:
+        if marker in markexpr:
+            continue
+        skip = pytest.mark.skip(reason=f"needs local services; run with -m {marker}")
+        for item in items:
+            if marker in item.keywords:
+                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,
+    ids=[c.python_version for c in COMPAT_CONFIGS],
+)
+def compat_config(request: pytest.FixtureRequest) -> CompatConfig:
+    return request.param
+
+
+@pytest.fixture(scope="module")
+def worker_project_dir() -> Path:
+    """Worker project the `dev_server` fixture should serve.
+
+    Test modules using `dev_server` must override this fixture.
+    """
+    raise NotImplementedError(
+        "override the `worker_project_dir` fixture in your test module"
+    )
+
+
+@pytest.fixture(scope="module")
+def dev_server(
+    tmp_path_factory: pytest.TempPathFactory,
+    worker_project_dir: Path,
+    compat_config: CompatConfig,
+) -> Generator[str]:
+    """Start a pywrangler dev server on a free port and yield its base URL."""
+    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")
+    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)
+
+    with run_dev_server(
+        target,
+        tmp_path,
+        env,
+        pywrangler_cmd,
+        startup_timeout=DEV_STARTUP_TIMEOUT,
+        readiness_path="/health",
+        require_success=True,
+        log_name="dev.log",
+    ) as (base_url, _):
+        yield base_url
+
+
+def register_in_worker_suites(
+    namespace: dict[str, Any],
+    src_dir: Path,
+    marks: dict[str, pytest.MarkDecorator] | None = None,
+) -> None:
+    register_testlib_suites(namespace, src_dir, marks=marks, class_name=str.upper)

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/tests/test_fastapi.py

@@ -4,9 +4,6 @@ Python 3.12 (Pyodide 0.26.0a2) is excluded. The in-worker pytest suite drives
 async tests via ``loop.run_until_complete``, which is a no-op on Pyodide 0.26.0a2
 (no ``run_sync``/JSPI): async tests return unawaited futures and report false
 passes.
-
-Python 3.14 is excluded because pydantic_core has a circular import error on
-the 3.14 Pyodide runtime (``validate_core_schema`` not found during module init).
 """
 
 from pathlib import Path
@@ -26,9 +23,8 @@ def worker_project_dir() -> Path:
 
 
 # Exclude Python 3.12 (Pyodide 0.26.0a2) for async tests.
-# Exclude Python 3.14 due to pydantic_core circular import error on Pyodide.
 FASTAPI_COMPAT_CONFIGS = [
-    c for c in COMPAT_CONFIGS if c.python_version not in ("3.12", "3.14")
+    c for c in COMPAT_CONFIGS if c.python_version not in ("3.12",)
 ]
 
 

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/tests/test_in_workerd.py

@@ -7,8 +7,7 @@ import pytest
 from conftest import (
     COMPAT_CONFIGS,
     CompatConfig,
-    inject_compat_flags,
-    replace_compat_date,
+    configure_compatibility,
 )
 
 TEST_DIR = Path(__file__).parent
@@ -30,6 +29,30 @@ def discover_workerd_tests():
     return cases
 
 
+def resolve_workerd(target: Path) -> str:
+    """Return the path to the workerd binary to use for tests.
+
+    If the ``WORKERD_PATH`` environment variable is set, it is used as-is (this
+    is useful for testing against a locally built workerd). Otherwise, workerd
+    is installed from npm into ``target`` and the installed binary is used.
+    """
+    workerd_path = os.environ.get("WORKERD_PATH")
+    if workerd_path:
+        workerd_bin = Path(workerd_path).expanduser().resolve()
+        if not workerd_bin.is_file():
+            raise FileNotFoundError(
+                f"WORKERD_PATH is set but does not point to a file: {workerd_bin}"
+            )
+        return str(workerd_bin)
+
+    subprocess.run(
+        ["npm", "i", "workerd"],
+        cwd=target,
+        check=True,
+    )
+    return "node_modules/workerd/bin/workerd"
+
+
 def embed(dir: Path, root: Path, level: int = 0):
     modules = []
     module_path_root = dir
@@ -62,7 +85,7 @@ def bundle_cache_dir(tmp_path_factory):
     ids=[c.python_version for c in COMPAT_CONFIGS],
 )
 @pytest.mark.parametrize("test_dir, wd_test_file", discover_workerd_tests())
-def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
+def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
     tmp_path,
     test_dir,
     wd_test_file,
@@ -71,22 +94,25 @@ def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
     bundle_cache_dir,
 ):
     compat_date = compat_config.compat_date
+    python_version = compat_config.python_version
 
     # `wsgi` streams the request body via `pyodide.ffi.run_sync` (JSPI), which
     # is only available in newer Pyodide runtimes.
-    if test_dir.name == "wsgi" and compat_date < "2026-01-01":
+    if test_dir.name == "wsgi" and python_version == "3.12":
         pytest.skip(
             "wsgi requires pyodide.ffi.run_sync (JSPI), unavailable before 2026-01-01"
         )
 
+    if test_dir.name == "http-client" and python_version < "3.14":
+        pytest.skip("HTTP client compatibility tests require Python 3.14 or newer")
+
     color = pytestconfig.get_terminal_writer().hasmarkup
     target = tmp_path / test_dir.name
     disk_service_dir = target / DISK_SERVICE_NAME
     shutil.copytree(test_dir, target, ignore=shutil.ignore_patterns(".venv"))
     disk_service_dir.mkdir(exist_ok=True)
 
-    replace_compat_date(target / "wrangler.jsonc", compat_date)
-    inject_compat_flags(target / "wrangler.jsonc", compat_config.extra_compat_flags)
+    configure_compatibility(target / "wrangler.jsonc", compat_config)
 
     pywrangler_cmd = ["uv", "run", "--no-project", "--with", WORKERS_PY, "pywrangler"]
 
@@ -114,15 +140,11 @@ def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
         .replace("%COLOR", str(color).lower())
         .replace("%COMPAT_DATE", compat_date)
     )
-    inject_compat_flags(wd_config, compat_config.extra_compat_flags)
+    configure_compatibility(wd_config, compat_config)
 
-    subprocess.run(
-        ["npm", "i", "workerd"],
-        cwd=target,
-        check=True,
-    )
+    workerd_bin = resolve_workerd(target)
     workerd_common = [
-        "node_modules/workerd/bin/workerd",
+        workerd_bin,
         "test",
         wd_test_file,
         "--experimental",

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.5}/tests/web-frameworks-test/django-async/pyproject.toml

@@ -10,4 +10,8 @@ dependencies = [
     "django-cors-headers",
     "pytest",
     "pytest-asyncio<1.2.0",
+    "testlib",
 ]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }