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

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

@@ -2,6 +2,15 @@
 
 <!-- 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

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

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

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

{workers_runtime_sdk-1.8.4 → 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
@@ -180,6 +204,30 @@ def langchain_openai_chat_models_base_context(module):
         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

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.4 → 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.4 → 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.4 → workers_runtime_sdk-1.8.5}/tests/test_in_workerd.py

@@ -29,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
@@ -79,10 +103,8 @@ def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
             "wsgi requires pyodide.ffi.run_sync (JSPI), unavailable before 2026-01-01"
         )
 
-    if test_dir.name == "entropy-patches" and python_version == "3.14":
-        pytest.skip(
-            "TODO: enable me after https://github.com/cloudflare/workerd/pull/7200 lands in wrangler"
-        )
+    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
@@ -120,13 +142,9 @@ def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
     )
     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.4 → workers_runtime_sdk-1.8.5}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -602,7 +602,7 @@ class FastAPIAppPlugin:
 
 @app.get("/run-tests/{suite_name:path}")
 async def run_suite(suite_name: str, request: Request):
-    runner = TestRunner(request.scope["env"])
+    runner = TestRunner(request.scope["env"], extra_plugins=[FastAPIAppPlugin()])
     result = runner.run_suite(suite_name)
     return JSONResponse(result.payload, status_code=result.status)
 

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.5}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -1,5 +1,6 @@
 import asyncio
 import contextlib
+import json
 
 import pytest
 from pyodide.ffi import create_proxy, to_js
@@ -61,9 +62,6 @@ async def _ws_connect(path):
     )
 
 
-import json
-
-
 async def _events():
     response = await asyncio.wait_for(
         env.SELF.fetch("http://example.com/ws-events"), TIMEOUT_S

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.5}/tests/workerd-test/entropy-patches/pyproject.toml

@@ -18,4 +18,6 @@ dependencies = [
     # "langchain-openai",
     # "openai",
     "litestar",
+    "opentelemetry-api",
+    "mcp; python_version >= '3.14'",
 ]

workers_runtime_sdk-1.8.5/tests/workerd-test/entropy-patches/tests/test_mcp.py

@@ -0,0 +1,10 @@
+# ruff: noqa: F401
+import sys
+
+if sys.version_info >= (3, 14):
+    import mcp
+
+
+def test_import():
+    # make sure this file is collected by pytest
+    pass

workers_runtime_sdk-1.8.5/tests/workerd-test/entropy-patches/tests/test_opentelemetry.py

@@ -0,0 +1,8 @@
+# ruff: noqa: F401
+import opentelemetry.context
+import opentelemetry.trace
+
+
+def test_import():
+    # make sure this file is collected by pytest
+    pass

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.5}/tests/workerd-test/entropy-patches/worker.py

@@ -4,7 +4,9 @@ from tests import (  # noqa: F401
     test_aiohttp_websocket,
     test_langsmith,
     test_litestar,
+    test_mcp,
     test_numpy,
+    test_opentelemetry,
     test_pydantic,
     test_rust_packages,
     test_ssl_avoidance,

workers_runtime_sdk-1.8.5/tests/workerd-test/http-client/http-client.wd-test

@@ -0,0 +1,45 @@
+using Workerd = import "/workerd/workerd.capnp";
+
+const client :Workerd.Worker = (
+  modules = [
+    (name = "worker.py", pythonModule = embed "worker.py"),
+    %PYTHON_MODULES
+  ],
+  bindings = [
+    (name = "color", json = "%COLOR"),
+  ],
+  globalOutbound = "external",
+  compatibilityDate = "%COMPAT_DATE",
+  compatibilityFlags = ["python_workers", "service_binding_extra_handlers"],
+);
+
+const origin :Workerd.Worker = (
+  modules = [
+    (name = "origin.py", pythonModule = embed "origin.py"),
+    %PYTHON_MODULES
+  ],
+  compatibilityDate = "%COMPAT_DATE",
+  compatibilityFlags = ["python_workers"],
+);
+
+const unitTests :Workerd.Config = (
+  services = [
+    (
+      name = "external",
+      external = (
+        address = "loopback:raw-http-origin",
+        tcp = (),
+      ),
+    ),
+    (name = "http-client", worker = .client),
+    (name = "http-origin", worker = .origin),
+  ],
+  sockets = [
+    (
+      name = "raw-http-origin",
+      address = "loopback:raw-http-origin",
+      http = (),
+      service = "http-origin",
+    ),
+  ],
+);

workers_runtime_sdk-1.8.5/tests/workerd-test/http-client/origin.py

@@ -0,0 +1,60 @@
+import json
+
+from workers import Response, WorkerEntrypoint
+
+
+class Default(WorkerEntrypoint):
+    async def fetch(self, request):
+        url = request.url
+        path = url.split("?", 1)[0].rsplit("/", 1)[-1]
+
+        match path:
+            case "echo":
+                return Response.json(
+                    {
+                        "method": request.method,
+                        "url": url,
+                        "custom": request.headers.get("X-Custom"),
+                        "content_type": request.headers.get("Content-Type"),
+                        "body": (await request.bytes()).decode(),
+                    }
+                )
+            case "body":
+                return Response(await request.text())
+            case "lines":
+                return Response("first\nsecond\nthird\n")
+            case "head":
+                return Response(
+                    "body that HEAD must not expose", headers={"X-Origin": "head"}
+                )
+            case "redirect":
+                return Response(
+                    "",
+                    status=302,
+                    headers={"Location": "http://example.com:80/final"},
+                )
+            case "final":
+                return Response("redirected")
+            case "error":
+                return Response(
+                    "teapot body",
+                    status=418,
+                    status_text="I'm a Teapot",
+                    headers={"X-Error": "expected"},
+                )
+            case "auth":
+                if request.headers.get("Authorization") != "Basic dXNlcjpwYXNz":
+                    return Response(
+                        "authentication required",
+                        status=401,
+                        headers={"WWW-Authenticate": 'Basic realm="compat"'},
+                    )
+                return Response("authenticated")
+            case "set-cookie":
+                return Response(
+                    "cookie set", headers={"Set-Cookie": "session=abc; Path=/"}
+                )
+            case "cookie":
+                return Response(request.headers.get("Cookie") or "")
+            case _:
+                return Response(json.dumps({"unexpected_url": url}), status=404)

workers_runtime_sdk-1.8.5/tests/workerd-test/http-client/pyproject.toml

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

workers_runtime_sdk-1.8.5/tests/workerd-test/http-client/tests/test_http_client.py

@@ -0,0 +1,162 @@
+import http.client
+import io
+import json
+
+import pytest
+
+HOST = "example.com"
+PORT = 80
+
+
+def connection():
+    return http.client.HTTPConnection(HOST, PORT)
+
+
+def get_json(response):
+    return json.loads(response.read())
+
+
+def test_http_connection_explicit_connect_and_close():
+    conn = connection()
+    try:
+        conn.connect()
+        assert conn.sock is not None
+    finally:
+        conn.close()
+    assert conn.sock is None
+
+
+def test_http_connection_lazy_connect_get_path_query_and_headers():
+    conn = connection()
+    try:
+        conn.request("GET", "/echo?name=workers", headers={"X-Custom": "present"})
+        payload = get_json(conn.getresponse())
+    finally:
+        conn.close()
+
+    assert payload == {
+        "method": "GET",
+        "url": "http://example.com/echo?name=workers",
+        "custom": "present",
+        "content_type": None,
+        "body": "",
+    }
+
+
+@pytest.mark.parametrize(
+    "body", ["text body", b"bytes body", bytearray(b"bytearray body")]
+)
+def test_http_connection_post_string_and_bytes_like_bodies(body):
+    conn = connection()
+    try:
+        conn.request("POST", "/body", body=body)
+        expected = bytes(body, "latin-1") if isinstance(body, str) else bytes(body)
+        assert conn.getresponse().read() == expected
+    finally:
+        conn.close()
+
+
+def test_http_connection_post_file_like_and_iterable_bodies():
+    for body in (io.BytesIO(b"file body"), [b"iter", b"able"]):
+        conn = connection()
+        try:
+            conn.request("POST", "/body", body=body, encode_chunked=True)
+            expected = b"file body" if hasattr(body, "read") else b"iterable"
+            assert conn.getresponse().read() == expected
+        finally:
+            conn.close()
+
+
+def test_http_connection_low_level_request_assembly_and_send():
+    conn = connection()
+    try:
+        conn.putrequest("POST", "/echo")
+        conn.putheader("Content-Length", "3")
+        conn.putheader("X-Custom", "low-level")
+        conn.endheaders()
+        conn.send(b"raw")
+        assert get_json(conn.getresponse()) == {
+            "method": "POST",
+            "url": "http://example.com/echo",
+            "custom": "low-level",
+            "content_type": None,
+            "body": "raw",
+        }
+    finally:
+        conn.close()
+
+
+def test_http_response_metadata_and_headers():
+    conn = connection()
+    try:
+        conn.request("GET", "/echo")
+        response = conn.getresponse()
+        assert response.status == 200
+        assert response.reason == "OK"
+        assert response.version == 11
+        assert response.getheader("content-type") == "application/json"
+        assert response.getheaders()
+        response.read()
+    finally:
+        conn.close()
+
+
+def test_http_response_read_methods_and_peek():
+    conn = connection()
+    try:
+        conn.request("GET", "/lines")
+        response = conn.getresponse()
+        assert response.peek(5).startswith(b"first")
+        assert response.read(5) == b"first"
+        target = bytearray(1)
+        assert response.readinto(target) == 1
+        assert target == b"\n"
+        assert response.read1(6) == b"second"
+        assert response.read() == b"\nthird\n"
+    finally:
+        conn.close()
+
+
+def test_http_response_line_iteration():
+    conn = connection()
+    try:
+        conn.request("GET", "/lines")
+        assert list(conn.getresponse()) == [b"first\n", b"second\n", b"third\n"]
+    finally:
+        conn.close()
+
+
+def test_http_connection_head_has_no_response_body():
+    conn = connection()
+    try:
+        conn.request("HEAD", "/head")
+        response = conn.getresponse()
+        assert response.status == 200
+        assert response.getheader("X-Origin") == "head"
+        assert response.read() == b""
+    finally:
+        conn.close()
+
+
+def test_http_connection_reuse_and_reconnect_after_close():
+    conn = connection()
+    try:
+        conn.request("GET", "/body")
+        assert conn.getresponse().read() == b""
+        conn.request("GET", "/lines")
+        assert conn.getresponse().read() == b"first\nsecond\nthird\n"
+        conn.close()
+        conn.request("GET", "/final")
+        assert conn.getresponse().read() == b"redirected"
+    finally:
+        conn.close()
+
+
+def test_http_connection_state_and_validation_errors():
+    conn = connection()
+    with pytest.raises(http.client.ResponseNotReady):
+        conn.getresponse()
+    with pytest.raises(http.client.CannotSendHeader):
+        conn.putheader("X-Test", "value")
+    with pytest.raises(ValueError):
+        conn.request("GET\n", "/echo")