workers-runtime-sdk 1.6.6__tar.gz → 1.6.7__tar.gz

{workers_runtime_sdk-1.6.6 → workers_runtime_sdk-1.6.7}/AGENTS.md

@@ -20,4 +20,4 @@ This package provides utilities for:
 ## Testing
 
 - All the tests should be done inside `workerd`, not in the host environment.
-- Tests should be implemented in `../cli/tests` directory.
+- Tests should be implemented in this package's `tests/` directory.

{workers_runtime_sdk-1.6.6 → workers_runtime_sdk-1.6.7}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 <!-- version list -->
 
+## v1.6.7 (2026-08-05)
+
+### Bug Fixes
+
+- Fix entropy patch for newer pydantic versions
+  ([#153](https://github.com/cloudflare/workers-py/pull/153),
+  [`81a4b6b`](https://github.com/cloudflare/workers-py/commit/81a4b6bad37373e0b448dd2dbedbf6cec0f47b8c))
+
+
 ## v1.6.6 (2026-08-03)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.6 → workers_runtime_sdk-1.6.7}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.6.6"
+version = "1.6.7"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -20,6 +20,7 @@ dev = [
   "pytest>=7.0.0",
   "ruff>=0.1.0",
   "mypy>=1.0.0",
+  "requests>=2.28.0",
 ]
 
 [project.urls]
@@ -56,6 +57,13 @@ lint.ignore = [
   "UP038", # Use X | Y instead of (X, Y)
 ]
 lint.flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
+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"]
+lint.per-file-ignores."tests/web-frameworks-test/**" = ["C901", "PLR0911", "PLR0912", "PLR2004", "PLW0603"]
+
+[tool.pytest.ini_options]
+addopts = ["--ignore=tests/workerd-test", "--ignore=tests/bindings-test", "--ignore=tests/web-frameworks-test"]
 
 [tool.mypy]
 packages = ["workers_runtime_sdk"]

{workers_runtime_sdk-1.6.6 → workers_runtime_sdk-1.6.7}/src/_workers_sdk_entropy_import_context.py

@@ -93,14 +93,10 @@ def pydantic_core_context(module):
         with allow_bad_entropy_calls(1):
             yield
     finally:
-        try:
-            with allow_bad_entropy_calls(1):
-                # validate_core_schema makes an ahash::AHashMap which makes
-                # another entropy call for its hash seed. It will throw an error
-                # but only after making the needed entropy call.
-                module.validate_core_schema(None)
-        except module.SchemaError:
-            pass
+        # Build a tiny validator instead so any lazy hash-map seeds are initialized
+        # before the snapshot is captured.
+        with allow_bad_entropy_calls(1):
+            module.SchemaValidator({"type": "any"})
 
 
 @register_exec_patch("aiohttp.http_websocket")

workers_runtime_sdk-1.6.7/tests/bindings-test/public/data.json

@@ -0,0 +1 @@
+{"key": "value", "number": 42}

workers_runtime_sdk-1.6.7/tests/bindings-test/public/hello.txt

@@ -0,0 +1 @@
+hello from static assets

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

@@ -0,0 +1,5 @@
+[project]
+name = "bindings-test"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0"]

workers_runtime_sdk-1.6.7/tests/bindings-test/src/conftest.py

@@ -0,0 +1,10 @@
+# pyright: reportMissingImports=false
+
+import pytest
+
+from workers import env as _env
+
+
+@pytest.fixture
+def env():
+    return _env

workers_runtime_sdk-1.6.7/tests/bindings-test/src/test_analytics_engine.py

@@ -0,0 +1,24 @@
+import pytest
+
+from workers.rpc import _BindingWrapper
+
+
+@pytest.mark.asyncio
+async def test_is_wrapped(env):
+    assert isinstance(env.ANALYTICS, _BindingWrapper)
+
+
+@pytest.mark.asyncio
+async def test_write_data_point_blobs_and_doubles(env):
+    env.ANALYTICS.writeDataPoint(
+        {
+            "blobs": ["blob1", "blob2"],
+            "doubles": [1.0, 2.5],
+            "indexes": ["idx"],
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_write_data_point_empty(env):
+    env.ANALYTICS.writeDataPoint({})

workers_runtime_sdk-1.6.7/tests/bindings-test/src/test_assets.py

@@ -0,0 +1,35 @@
+import pytest
+
+from workers.rpc import _FetcherWrapper
+
+
+@pytest.mark.asyncio
+async def test_is_fetcher_wrapper(env):
+    assert isinstance(env.ASSETS, _FetcherWrapper)
+
+
+@pytest.mark.asyncio
+async def test_fetch_text_file(env):
+    resp = await env.ASSETS.fetch("https://assets.local/hello.txt")
+    text = await resp.text()
+    assert text.strip() == "hello from static assets"
+
+
+@pytest.mark.asyncio
+async def test_fetch_json_file(env):
+    resp = await env.ASSETS.fetch("https://assets.local/data.json")
+    data = await resp.json()
+    assert data["key"] == "value"
+    assert data["number"] == 42
+
+
+@pytest.mark.asyncio
+async def test_fetch_returns_404_for_missing(env):
+    resp = await env.ASSETS.fetch("https://assets.local/nonexistent.txt")
+    assert resp.status == 404
+
+
+@pytest.mark.asyncio
+async def test_fetch_content_type(env):
+    resp = await env.ASSETS.fetch("https://assets.local/data.json")
+    assert "application/json" in resp.headers.get("content-type")

workers_runtime_sdk-1.6.7/tests/bindings-test/src/test_d1.py

@@ -0,0 +1,498 @@
+import pytest
+from pyodide.ffi import JsException
+
+from workers.rpc import _BindingWrapper, _RpcStubWrapper
+
+TEST_TABLE = "_test_d1"
+TEST_TABLE_TYPES = "_test_d1_types"
+TEST_TABLE_BATCH = "_test_d1_batch"
+EXEC_TABLE = "_test_d1_exec_tmp"
+EXEC_MULTI_TABLE = "_test_d1_exec_multi"
+
+
+async def _cleanup_d1(db):
+    for table in [
+        TEST_TABLE,
+        TEST_TABLE_TYPES,
+        TEST_TABLE_BATCH,
+        EXEC_TABLE,
+        EXEC_MULTI_TABLE,
+    ]:
+        try:
+            await db.exec(f"DROP TABLE IF EXISTS {table}")
+        except Exception:
+            pass
+
+
+async def _ensure_tables(db):
+    await db.exec(
+        f"CREATE TABLE IF NOT EXISTS {TEST_TABLE} "
+        f"(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, value TEXT)"
+    )
+    await db.exec(
+        f"CREATE TABLE IF NOT EXISTS {TEST_TABLE_TYPES} "
+        f"(id INTEGER PRIMARY KEY, txt TEXT, num REAL, intval INTEGER)"
+    )
+    await db.exec(
+        f"CREATE TABLE IF NOT EXISTS {TEST_TABLE_BATCH} "
+        f"(id INTEGER PRIMARY KEY, val TEXT)"
+    )
+
+
+@pytest.mark.asyncio
+async def test_chained_statements_stay_binding_wrappers(env):
+    # A binding method returning another binding object must keep the plain
+    # binding wrapper.
+    statement = env.DB.prepare(f"SELECT 1 FROM {TEST_TABLE} WHERE name = ?")
+    assert isinstance(statement, _BindingWrapper)
+    assert not isinstance(statement, _RpcStubWrapper)
+    assert not callable(statement)
+
+    bound = statement.bind("x")
+    assert isinstance(bound, _BindingWrapper)
+    assert not isinstance(bound, _RpcStubWrapper)
+    assert not callable(bound)
+
+
+@pytest.mark.asyncio
+async def test_insert_and_select_via_run(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    insert_result = (
+        await db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("run_test", "hello")
+        .run()
+    )
+    assert insert_result["success"] is True
+    meta = insert_result["meta"]
+    assert meta["changes"] >= 1
+    assert meta["last_row_id"] > 0
+    row_id = meta["last_row_id"]
+    select_result = (
+        await db.prepare(f"SELECT id, name, value FROM {TEST_TABLE} WHERE id = ?")
+        .bind(row_id)
+        .run()
+    )
+    rows = select_result["results"]
+    assert len(rows) == 1
+    assert rows[0]["name"] == "run_test"
+    assert rows[0]["value"] == "hello"
+
+
+@pytest.mark.asyncio
+async def test_all_returns_results(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("all_test", "v1")
+        .run()
+    )
+    result = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ?")
+        .bind("all_test")
+        .all()
+    )
+    assert result["success"] is True
+    rows = result["results"]
+    assert len(rows) >= 1
+    assert rows[0]["name"] == "all_test"
+
+
+@pytest.mark.asyncio
+async def test_first_returns_single_row(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("first_test", "fv")
+        .run()
+    )
+    row = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("first_test")
+        .first()
+    )
+    assert row is not None, "first() returned None"
+    assert isinstance(row, dict)
+    assert row["name"] == "first_test"
+    assert row["value"] == "fv"
+
+
+@pytest.mark.asyncio
+async def test_first_with_column_name(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("first_col", "col_val")
+        .run()
+    )
+    value = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("first_col")
+        .first("value")
+    )
+    assert value == "col_val"
+
+
+@pytest.mark.asyncio
+async def test_first_on_empty_result(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    row = (
+        await db.prepare(f"SELECT * FROM {TEST_TABLE} WHERE name = ?")
+        .bind("__nonexistent__xyz__")
+        .first()
+    )
+    assert row is None
+
+
+@pytest.mark.asyncio
+async def test_raw_returns_arrays(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("raw_test", "rv")
+        .run()
+    )
+    rows = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("raw_test")
+        .raw()
+    )
+    assert isinstance(rows, list)
+    assert len(rows) == 1
+    assert rows[0] == ["raw_test", "rv"]
+
+
+@pytest.mark.asyncio
+async def test_raw_with_column_names(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("raw_cols", "rc")
+        .run()
+    )
+    rows = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("raw_cols")
+        .raw(columnNames=True)
+    )
+    assert len(rows) == 2
+    assert rows[0] == ["name", "value"]
+    assert rows[1] == ["raw_cols", "rc"]
+
+
+@pytest.mark.asyncio
+async def test_bind_types(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+
+    await (
+        db.prepare(
+            f"INSERT INTO {TEST_TABLE_TYPES} (id, txt, num, intval) VALUES (?, ?, ?, ?)"
+        )
+        .bind(2, "hello, D1!", 3.14, 42)
+        .run()
+    )
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE_TYPES} (id, intval) VALUES (?, ?)")
+        .bind(3, True)
+        .run()
+    )
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE_TYPES} (id, intval) VALUES (?, ?)")
+        .bind(4, False)
+        .run()
+    )
+
+    row2 = (
+        await db.prepare(
+            f"SELECT txt, num, intval FROM {TEST_TABLE_TYPES} WHERE id = ?"
+        )
+        .bind(2)
+        .first()
+    )
+    assert row2["txt"] == "hello, D1!"
+    assert abs(row2["num"] - 3.14) < 0.001
+    assert row2["intval"] == 42
+
+    row3 = (
+        await db.prepare(f"SELECT intval FROM {TEST_TABLE_TYPES} WHERE id = ?")
+        .bind(3)
+        .first()
+    )
+    row4 = (
+        await db.prepare(f"SELECT intval FROM {TEST_TABLE_TYPES} WHERE id = ?")
+        .bind(4)
+        .first()
+    )
+    assert row3["intval"] == 1
+    assert row4["intval"] == 0
+
+
+@pytest.mark.asyncio
+async def test_exec_create_and_query(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    result = await db.exec(
+        f"CREATE TABLE IF NOT EXISTS {EXEC_TABLE} (id INTEGER PRIMARY KEY, val TEXT)"
+    )
+    assert result["count"] >= 1
+    assert result["duration"] >= 0
+
+
+@pytest.mark.asyncio
+async def test_exec_multiple_statements(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    result = await db.exec(
+        f"CREATE TABLE IF NOT EXISTS {EXEC_MULTI_TABLE} (id INTEGER PRIMARY KEY, val TEXT);\n"
+        f"INSERT INTO {EXEC_MULTI_TABLE} (val) VALUES ('a');\n"
+        f"INSERT INTO {EXEC_MULTI_TABLE} (val) VALUES ('b');"
+    )
+    assert result["count"] >= 3
+    rows = await db.prepare(f"SELECT val FROM {EXEC_MULTI_TABLE} ORDER BY val").raw()
+    assert rows == [["a"], ["b"]]
+
+
+@pytest.mark.asyncio
+async def test_batch_multiple_inserts(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    statements = [
+        db.prepare(f"INSERT INTO {TEST_TABLE_BATCH} (id, val) VALUES (?, ?)").bind(
+            1, "batch_a"
+        ),
+        db.prepare(f"INSERT INTO {TEST_TABLE_BATCH} (id, val) VALUES (?, ?)").bind(
+            2, "batch_b"
+        ),
+        db.prepare(f"INSERT INTO {TEST_TABLE_BATCH} (id, val) VALUES (?, ?)").bind(
+            3, "batch_c"
+        ),
+    ]
+    results = await db.batch(statements)
+    assert results is not None, "batch returned None"
+    all_rows = await db.prepare(
+        f"SELECT id, val FROM {TEST_TABLE_BATCH} ORDER BY id"
+    ).all()
+    rows = all_rows["results"]
+    assert len(rows) == 3
+    assert [row["val"] for row in rows] == ["batch_a", "batch_b", "batch_c"]
+
+
+@pytest.mark.asyncio
+async def test_run_metadata_fields(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    result = (
+        await db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("meta_test", "mv")
+        .run()
+    )
+    assert result["success"] is True
+    meta = result["meta"]
+    for key in [
+        "duration",
+        "changes",
+        "last_row_id",
+        "changed_db",
+        "rows_read",
+        "rows_written",
+        "size_after",
+    ]:
+        assert key in meta
+    assert meta["changes"] >= 1
+    assert meta["changed_db"] is True
+
+
+@pytest.mark.asyncio
+async def test_update_row(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    insert_result = (
+        await db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("update_me", "old_value")
+        .run()
+    )
+    row_id = insert_result["meta"]["last_row_id"]
+    update_result = (
+        await db.prepare(f"UPDATE {TEST_TABLE} SET value = ? WHERE id = ?")
+        .bind("new_value", row_id)
+        .run()
+    )
+    assert update_result["meta"]["changes"] == 1
+    row = (
+        await db.prepare(f"SELECT value FROM {TEST_TABLE} WHERE id = ?")
+        .bind(row_id)
+        .first()
+    )
+    assert row["value"] == "new_value"
+
+
+@pytest.mark.asyncio
+async def test_delete_row(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    insert_result = (
+        await db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("delete_me", "gone")
+        .run()
+    )
+    row_id = insert_result["meta"]["last_row_id"]
+    delete_result = (
+        await db.prepare(f"DELETE FROM {TEST_TABLE} WHERE id = ?").bind(row_id).run()
+    )
+    assert delete_result["meta"]["changes"] == 1
+    row = (
+        await db.prepare(f"SELECT * FROM {TEST_TABLE} WHERE id = ?")
+        .bind(row_id)
+        .first()
+    )
+    assert row is None
+
+
+@pytest.mark.asyncio
+async def test_session_prepare_and_query(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("session_test", "sv")
+        .run()
+    )
+    session = db.withSession()
+    assert session is not None, "withSession() returned None"
+    result = await session.prepare(f"SELECT COUNT(*) as cnt FROM {TEST_TABLE}").all()
+    assert result["success"] is True
+    assert result["results"][0]["cnt"] >= 1
+
+
+@pytest.mark.asyncio
+async def test_session_bookmark(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    session = db.withSession()
+    bookmark_before = session.getBookmark()
+    assert bookmark_before is None
+    await session.prepare("SELECT 1").all()
+    bookmark_after = session.getBookmark()
+    assert bookmark_after is not None
+    assert isinstance(bookmark_after, str)
+    assert len(bookmark_after) > 0
+
+
+@pytest.mark.asyncio
+async def test_session_batch(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    session = db.withSession()
+    statements = [
+        session.prepare(f"INSERT INTO {TEST_TABLE_BATCH} (id, val) VALUES (?, ?)").bind(
+            1, "sa"
+        ),
+        session.prepare(f"INSERT INTO {TEST_TABLE_BATCH} (id, val) VALUES (?, ?)").bind(
+            2, "sb"
+        ),
+    ]
+    results = await session.batch(statements)
+    assert results is not None, "session batch returned None"
+    rows = await session.prepare(
+        f"SELECT id, val FROM {TEST_TABLE_BATCH} ORDER BY id"
+    ).all()
+    assert len(rows["results"]) == 2
+    assert rows["results"][0]["val"] == "sa"
+    assert rows["results"][1]["val"] == "sb"
+
+
+@pytest.mark.asyncio
+async def test_invalid_sql_raises_error(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    with pytest.raises(JsException, match="syntax error"):
+        await db.prepare("INVALID SQL GIBBERISH").run()
+
+
+@pytest.mark.asyncio
+async def test_raw_dict_column_names(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("dict_raw", "dr")
+        .run()
+    )
+    rows = await (
+        db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("dict_raw")
+        .raw({"columnNames": True})
+    )
+    assert len(rows) == 2
+    assert rows[0] == ["name", "value"]
+    assert rows[1] == ["dict_raw", "dr"]
+
+
+@pytest.mark.asyncio
+async def test_bind_null(env):
+    import sys
+
+    if sys.version_info < (3, 13):
+        pytest.skip("Pyodide 0.26 (Python 3.12) cannot represent JS null")
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(
+            f"INSERT INTO {TEST_TABLE_TYPES} (id, txt, num, intval) VALUES (?, ?, ?, ?)"
+        )
+        .bind(1, None, None, None)
+        .run()
+    )
+    row = (
+        await db.prepare(
+            f"SELECT txt, num, intval FROM {TEST_TABLE_TYPES} WHERE id = ?"
+        )
+        .bind(1)
+        .first()
+    )
+    assert row["txt"] is None
+    assert row["num"] is None
+    assert row["intval"] is None
+
+
+@pytest.mark.asyncio
+async def test_none_options_raw(env):
+    db = env.DB
+    await _cleanup_d1(db)
+    await _ensure_tables(db)
+    await (
+        db.prepare(f"INSERT INTO {TEST_TABLE} (name, value) VALUES (?, ?)")
+        .bind("none_raw", "nr")
+        .run()
+    )
+    rows = (
+        await db.prepare(f"SELECT name, value FROM {TEST_TABLE} WHERE name = ? LIMIT 1")
+        .bind("none_raw")
+        .raw(None)
+    )
+    assert len(rows) == 1
+    assert rows[0] == ["none_raw", "nr"]