crosswind-workers 0.1.0__py3-none-any.whl

_crosswind_patches/__init__.py

@@ -0,0 +1,13 @@
+"""Package patches that workerd leaves to the SDK.
+
+With `python_process_pth_files` on, workerd stops bundling its per-package
+entropy patches and runs `.pth` files instead, and `crosswind_workers_patches.pth`
+imports this package at startup. The patches are ported from the stock SDK at
+cb2db3c. They hook imports through workerd's `_cloudflare` package, so a patch
+applies only when its package is imported, and nothing happens outside workerd.
+"""
+
+import importlib.util
+
+if importlib.util.find_spec("_cloudflare") is not None:
+    from . import entropy, runtime  # noqa: F401

_crosswind_patches/entropy.py

@@ -0,0 +1,259 @@
+"""
+Top level entropy patches for packages
+"""
+
+import sys
+from collections.abc import Sequence
+from contextlib import contextmanager
+from importlib.abc import MetaPathFinder
+from importlib.machinery import ModuleSpec
+from importlib.metadata import PackageNotFoundError, version
+from types import ModuleType
+
+from _cloudflare.allow_entropy import (
+    allow_bad_entropy_calls,
+)
+from _cloudflare.import_patch_manager import (
+    block_calls,
+    register_after_snapshot,
+    register_before_first_request,
+    register_create_patch,
+    register_exec_patch,
+)
+
+
+@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
+
+
+@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):
+    """Rust packages need one entropy call if they create a rust hash map at
+    init time.
+
+    For reasons I don't entirely understand, in Pyodide 0.28 only the first Rust
+    package to be imported makes the get_entropy call. See gen_rust_import_tests()
+    which tests that importing four rust packages in different permutations works
+    correctly.
+    """
+    if STATE.imported_rust_package:
+        yield
+        return
+
+    STATE.imported_rust_package = True
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("numpy.random")
+@contextmanager
+def numpy_random_context(numpy_random):
+    """numpy.random doesn't call getentropy() itself, but we want to block calls
+    that might use the bad seed.
+
+    TODO: Maybe there are more calls we can whitelist?
+    TODO: Is it not enough to just block numpy.random.mtrand calls?
+    """
+    yield
+    # Calling default_rng() with a given seed is fine, calling it without a seed
+    # will call getentropy() and fail.
+    block_calls(numpy_random, allowlist=("default_rng", "RandomState"))
+
+
+@register_after_snapshot("numpy.random")
+def numpy_random_after_snapshot(numpy_random):
+    r1 = numpy_random.random()
+    numpy_random.set_state(STATE.numpy_random)
+    r2 = numpy_random.random()
+    if r1 != r2:
+        raise RuntimeError("random seed in bad state")
+
+
+@register_before_first_request("numpy.random")
+def numpy_random_before_first_request(numpy_random):
+    numpy_random.seed()
+
+
+@register_exec_patch("numpy.random.mtrand")
+@contextmanager
+def numpy_random_mtrand_context(module):
+    # numpy.random.mtrand calls secrets.randbits at top level to seed itself.
+    # This will fail if we don't let it through.
+    with allow_bad_entropy_calls(1):
+        yield
+    # Block calls until we get a chance to replace the bad random seed.
+    STATE.numpy_random = module.get_state()
+    block_calls(module, allowlist=("RandomState",))
+
+
+@register_exec_patch("pydantic_core")
+@contextmanager
+def pydantic_core_context(module):
+    try:
+        # Initial import needs one entropy call to initialize
+        # std::collections::HashMap hash seed
+        with allow_bad_entropy_calls(1):
+            yield
+    finally:
+        # 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")
+@contextmanager
+def aiohttp_http_websocket_context(module):
+    import random
+
+    original = random.Random
+    # The module stands in for the Random() aiohttp builds at import time.
+    # setattr, because the stand-in is not a type, so ty rejects an assignment.
+    setattr(random, "Random", lambda: random)  # noqa: B010
+    try:
+        yield
+    finally:
+        random.Random = original
+
+
+class NoSslFinder(MetaPathFinder):
+    def find_spec(
+        self,
+        fullname: str,
+        path: Sequence[str] | None,
+        target: ModuleType | None = None,
+    ) -> ModuleSpec | None:
+        if fullname == "ssl":
+            raise ModuleNotFoundError(
+                f"No module named {fullname!r}", name=fullname
+            ) from None
+        return None
+
+
+@contextmanager
+def no_ssl():
+    """
+    Various packages will call ssl.create_default_context() at top level which uses
+    entropy if they can import ssl. By temporarily making importing ssl raise an
+    import error, we exercise the workaround code and so avoid the entropy calls.
+    After, we put the ssl module back to the normal value.
+    """
+    try:
+        f = NoSslFinder()
+        ssl = sys.modules.pop("ssl", None)
+        sys.meta_path.insert(0, f)
+        yield
+    finally:
+        sys.meta_path.remove(f)
+        if ssl:
+            sys.modules["ssl"] = ssl
+
+
+@register_exec_patch("aiohttp.connector")
+@contextmanager
+def aiohttp_connector_context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("requests.adapters")
+@contextmanager
+def requests_adapters_context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("urllib3.util.ssl_")
+@contextmanager
+def urllib3_util_ssl__context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("langsmith._internal._constants")
+@contextmanager
+def langsmith__internal__constants_context(module):
+    # Langsmith uses a UUID to communicate with a background thread. This obviously
+    # won't work so we might as well allow it to make a UUID.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("langchain_openai.chat_models.base")
+@contextmanager
+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("fastapi.telemetry")
+@contextmanager
+def fastapi_telemetry_context(module):
+    # fastapi 0.142.0 added opentelemetry support
+    # which creates a UUID-backed key.
+    with allow_bad_entropy_calls_for_version("fastapi", 1, (0, 142, 0)):
+        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

_crosswind_patches/runtime.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

asgi/__init__.py

@@ -0,0 +1,7 @@
+"""`import asgi`, the stock SDK's older import path for `workers.asgi`."""
+
+import sys
+
+from workers import asgi as _asgi
+
+sys.modules[__name__] = _asgi

crosswind_workers-0.1.0.data/purelib/crosswind_workers_patches.pth

@@ -0,0 +1 @@
+import _crosswind_patches

crosswind_workers-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: crosswind-workers
+Version: 0.1.0
+Summary: Typed, Pythonic drop-in replacement for Cloudflare's workers-runtime-sdk
+Author: Viswa Marepalli
+Author-email: Viswa Marepalli <reachvishm@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

crosswind_workers-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+_crosswind_patches/__init__.py,sha256=X9yG9DBf8RBGeufuHHsY8s8hWm07DFUBtG2UEnvTuq4,580
+_crosswind_patches/entropy.py,sha256=83ocwaBDtuA7__cJRZzBuY7bxiuU-_kluNtdUgnzjpI,7551
+_crosswind_patches/runtime.py,sha256=Xbsukr-l2_SBWRJ1aErQ7eoGo4sqDFFDfHWSbWE2WX4,1868
+asgi/__init__.py,sha256=lAOCoCmnC5gXiW5PcmGkLHCq5W0U55snJYSEwNBJ2YQ,153
+workers/__init__.py,sha256=9J5xggHH_0vwCUjU_SufXK5Cypo-SoLZd8Rvw4Nijzk,2778
+workers/_adapter.py,sha256=SToaS9ONcNdJTlprR1Di8YWjjpTPYjrySySr5LiXL48,950
+workers/_body.py,sha256=gwRJttYqBnSeeLX71DJCRWRwfSnagAEUUxrEPMdYqGs,898
+workers/_js.py,sha256=ZSdaV0dwaW0qWUZgNGAF-oA45XCY933PD04X6TgS3cA,3611
+workers/asgi.py,sha256=Y02rznPW1ZlOeo5hYrCwkKud2dU15gSGzNFG0effR2U,18852
+workers/bindings/__init__.py,sha256=XvJx5NlBJaSt_8VgA3iz-_jntyywpExXaYlzTODTv5I,1170
+workers/bindings/base.py,sha256=DXRU4G9zZUA83sxPtxihRboCRj4-D3sO3BYIq2RTw6E,4750
+workers/bindings/d1.py,sha256=_p_la1JJn6NRNXejhsxj143p_eeKSU5vioRH8Y0h6LA,1599
+workers/bindings/env.py,sha256=h23XAKU05eiJaRgw2O0xZUBI4ZSmzU0QrLUc77IWMyE,1515
+workers/bindings/kv.py,sha256=p66wqgyaQ1nxElhcZowV4Wlv9zylr87gfXSoZ3XYITk,3276
+workers/bindings/queues.py,sha256=GuvlG0xKnm-9UePYR_w5ZNBX0rQb5B0Q0buM-207Lq8,970
+workers/bindings/r2.py,sha256=P8seoIxkZmRMLZkvYW7n4uwyApc8Y9VbakYVpZRI-0Y,3482
+workers/bindings/services.py,sha256=lxxfgySmHC0v_lD7j25sFexHJ8jDhRSbBwe6HBUoq3k,2035
+workers/bindings/workflow.py,sha256=RKcNJHKtE3X6OGGvCXo6qYVUjxahkW5qJdQxdUJ_dpo,1864
+workers/blob.py,sha256=YVgUKdqoW0Iy4Jeatspiu3bDc65KoyS1HCo0lnH1R9o,4539
+workers/context.py,sha256=yPGuiKYmDO0_sF_JOXzpgXWD85wU2VaHFWuR_zlslF4,7965
+workers/entrypoints.py,sha256=SNUJcGP7mfOt3a79rg5Zd-GPbi7OiqhJ8Ed6yqlifTs,6188
+workers/fetch.py,sha256=O3iyn_2GGQJFJoTnef8mlVvbRFMd8P1UIjllwkWzaP8,1608
+workers/formdata.py,sha256=LwuZAAHNMU-GguaKQLtHsv1Iz274oId5O2-OZm6IVeg,3215
+workers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workers/request.py,sha256=7Md0vLWLi2U5BMQ9I2l3ooi8UUsb7CZ9a90yrCI5twA,3878
+workers/response.py,sha256=Xtq5SUuFO9U1X4aXCNyVBxS7OHeQWHX9FUc51QGuPMY,6164
+workers/rpc.py,sha256=LuVv2fnxqzxAl62g1YDlTI03UyZFHg0xG4oOvsT-7EY,4623
+workers/types.py,sha256=8fxCdEPqTSZ32AS2EDnSh4nzPp81lgv2t5n4difJw-A,1542
+workers/utils.py,sha256=6EqXQYeY3x6eKAYAac4E8pssE2vJ2VOxhkc1e-UxEus,2066
+workers/workflows.py,sha256=nbQmgPX6leuJZCKuacLLU3nxa3DaWON2Ms3SNSKAPu8,9631
+workers/wsgi.py,sha256=7ir1_vQbz1comSYM8QmY1gfD8NE7CX4epD_vKpkJybs,14390
+crosswind_workers-0.1.0.data/purelib/crosswind_workers_patches.pth,sha256=Z0CLXaLtPU3a08bW3w2y3ti-vr1l2oYbfaulcGx1sfk,26
+crosswind_workers-0.1.0.dist-info/WHEEL,sha256=e4_1dyBeezi8ZjfxrZ3bnVOxFDa3ksqVqH0jTHkUZ3k,81
+crosswind_workers-0.1.0.dist-info/METADATA,sha256=yugjwOJzgQ5E8lrgOSoqBgdZxrdf2M0D7jxrGB6Neag,285
+crosswind_workers-0.1.0.dist-info/RECORD,,

crosswind_workers-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.19
+Root-Is-Purelib: true
+Tag: py3-none-any

workers/__init__.py

@@ -0,0 +1,88 @@
+from importlib.metadata import PackageNotFoundError as _PackageNotFoundError
+from importlib.metadata import distribution as _distribution
+from typing import Any as _Any
+
+# Both SDKs install the `workers` package, so with both installed one
+# overwrote the other's files. This check survives only if crosswind's did.
+try:
+    _distribution("workers-runtime-sdk")
+except _PackageNotFoundError:
+    pass
+else:
+    raise ImportError(
+        "workers-runtime-sdk is installed beside crosswind-workers, and both "
+        "provide the `workers` package, so one has overwritten the other. "
+        "Remove workers-runtime-sdk. pywrangler always adds it, so build "
+        "crosswind-workers projects with Wynd, which installs only the SDK the "
+        "project declares."
+    )
+
+from .bindings import _EnvWrapper
+from .blob import Blob, BlobEnding, BlobValue, File
+from .context import js_promise as _js_promise
+from .entrypoints import DurableObject, WorkerEntrypoint, WorkflowEntrypoint, handler
+from .fetch import fetch
+from .formdata import FormData, FormDataValue
+from .request import Request
+from .response import FetchResponse, Response
+from .rpc import python_from_rpc, python_to_rpc
+from .types import (
+    Body,
+    Context,
+    FetchKwargs,
+    Headers,
+    JSBody,
+    RequestInitCfProperties,
+)
+from .utils import import_from_javascript, patch_env
+
+__all__ = [
+    "Blob",
+    "BlobEnding",
+    "BlobValue",
+    "Body",
+    "Context",
+    "DurableObject",
+    "FetchKwargs",
+    "FetchResponse",
+    "File",
+    "FormData",
+    "FormDataValue",
+    "Headers",
+    "JSBody",
+    "Request",
+    "RequestInitCfProperties",
+    "Response",
+    "WorkerEntrypoint",
+    "WorkflowEntrypoint",
+    "env",
+    "fetch",
+    "handler",
+    "import_from_javascript",
+    "patch_env",
+    "python_from_rpc",
+    "python_to_rpc",
+    "waitUntil",
+    "wait_until",
+]
+
+
+def _wait_until(awaitable: _Any) -> None:
+    """Hand `awaitable` to cloudflare:workers' waitUntil, as the stock SDK does.
+
+    Under wrangler dev that waitUntil doesn't keep a Python Worker alive past
+    the response, with this or with the stock SDK. `ctx.wait_until` does.
+    """
+    import_from_javascript("cloudflare:workers").waitUntil(_js_promise(awaitable))
+
+
+def __getattr__(name: str) -> _Any:
+    # Served on access, as in the stock SDK: importing workers holds no JS
+    # object, which snapshot creation requires.
+    if name == "env":
+        return _EnvWrapper(import_from_javascript("cloudflare:workers").env)
+    if name in ("wait_until", "waitUntil"):
+        # workerd's own waitUntil drops a coroutine handed to it, so this
+        # passes a promise that follows it, as ctx.wait_until does.
+        return _wait_until
+    raise AttributeError(f"module 'workers' has no attribute {name!r}")

workers/_adapter.py

@@ -0,0 +1,24 @@
+"""Request and response handling shared by the ASGI and WSGI adapters."""
+
+from collections.abc import Iterable
+from typing import Any
+
+from .request import Request
+
+# 101/103/204/205/304 must not carry a body per the Fetch spec.
+# https://fetch.spec.whatwg.org/#null-body-status
+NULL_BODY_STATUSES = frozenset({101, 103, 204, 205, 304})
+
+
+def request_headers(req: Any) -> Iterable[tuple[str, str]]:
+    """The header pairs of a `workers.Request` or a `js.Request`."""
+    return req.headers.items() if isinstance(req, Request) else req.headers
+
+
+def body_encoding(headers: Iterable[tuple[str, str]]) -> dict[str, str]:
+    """The `Response` init entry for a body the app has already encoded."""
+    if any(name.lower() == "content-encoding" for name, _ in headers):
+        # The app encoded the body already, as GZipMiddleware does. Without
+        # this the runtime encodes it a second time.
+        return {"encodeBody": "manual"}
+    return {}

workers/_body.py

@@ -0,0 +1,34 @@
+"""What Request and Response share on top of their JS object."""
+
+from typing import TYPE_CHECKING, Any
+
+from ._js import headers_to_message, python_errors
+from .blob import Blob
+from .formdata import FormData
+
+
+class BodyMixin:
+    """Headers and the body readers pyodide's FetchResponse lacks.
+
+    Built on `js_object`, a JS Request or Response, and `_raise_if_failed`.
+    """
+
+    if TYPE_CHECKING:
+
+        @property
+        def js_object(self) -> Any: ...
+
+        def _raise_if_failed(self) -> None: ...
+
+    @property
+    def headers(self) -> Any:
+        return headers_to_message(self.js_object.headers)
+
+    async def form_data(self) -> FormData:
+        self._raise_if_failed()
+        with python_errors():
+            return FormData(await self.js_object.formData())
+
+    async def blob(self) -> Blob:
+        self._raise_if_failed()
+        return Blob(await self.js_object.blob())

workers/_js.py

@@ -0,0 +1,121 @@
+"""Helpers for crossing between Python and JS values."""
+
+import http.client
+from collections.abc import Generator, Mapping
+from contextlib import contextmanager
+from typing import Any
+
+import js
+from pyodide.ffi import JsException, create_proxy, destroy_proxies
+
+try:
+    # Pyodide 0.28 added jsnull. The pyodide-py stubs for 3.12 (0.27.8) lack it.
+    from pyodide.ffi import jsnull  # ty: ignore[unresolved-import]
+except ImportError:
+    # Pyodide 0.26 (the 3.12 target) has no jsnull, so None crosses as undefined.
+    jsnull = None
+
+try:
+    import _cloudflare_compat_flags
+except ImportError:  # outside workerd
+    _cloudflare_compat_flags = None
+
+
+def js_name(value: Any) -> str | None:
+    """The JS constructor name of a JS value, or None for a Python value."""
+    return value.constructor.name if hasattr(value, "constructor") else None
+
+
+def none_if_null(value: Any) -> Any:
+    return None if value is jsnull else value
+
+
+def compat_flag(name: str) -> bool:
+    return bool(getattr(_cloudflare_compat_flags, name, False))
+
+
+@contextmanager
+def js_body(body: Any) -> Generator[Any]:
+    """The JS value for a request or response body, valid inside the block."""
+    if isinstance(body, bytes):
+        with lend_buffer(body) as view:
+            yield view
+    elif hasattr(body, "js_object"):
+        yield body.js_object
+    else:
+        yield body
+
+
+@contextmanager
+def lend_buffer(value: Any) -> Generator[Any]:
+    """A JS view of a Python buffer, without a copy, valid inside the block."""
+    proxy = create_proxy(value)
+    buffer = proxy.getBuffer()
+
+    try:
+        yield buffer.data
+    finally:
+        buffer.release()
+        proxy.destroy()
+
+
+@contextmanager
+def managed_pyproxies() -> Generator[Any]:
+    proxies = js.Array.new()
+    try:
+        yield proxies
+    finally:
+        destroy_proxies(proxies)
+
+
+# JS errors with a Python twin, by JS name.
+_PYTHON_ERRORS = {"RangeError": ValueError, "TypeError": TypeError}
+
+
+@contextmanager
+def python_errors() -> Generator[None]:
+    """Raise a JS RangeError or TypeError from the block as its Python twin."""
+    try:
+        yield
+    except JsException as error:
+        python_error = _PYTHON_ERRORS.get(error.name)
+        if python_error is None:
+            raise
+        raise python_error(error.message) from error
+
+
+def to_js_headers(headers: Any) -> Any:
+    if isinstance(headers, list):
+        return js.Headers.new(headers)
+    if isinstance(headers, dict):
+        return js.Headers.new(headers.items())
+    if js_name(headers) == "Headers":
+        return headers
+    raise TypeError("Received unexpected type for headers argument")
+
+
+# The stock SDK's type: an HTTPMessage that is also a Mapping. The two bases
+# type keys(), get() and the rest differently, which ty reports.
+class HTTPMessageMapping(http.client.HTTPMessage, Mapping):  # ty: ignore[invalid-method-override]
+    pass
+
+
+def headers_to_message(js_headers: Any) -> HTTPMessageMapping:
+    # Newer Pyodide versions already expose headers as an HTTPMessage.
+    if isinstance(js_headers, HTTPMessageMapping):
+        return js_headers
+
+    result = HTTPMessageMapping()
+    if not compat_flag("python_request_headers_preserve_commas"):
+        for key, value in js_headers:
+            result[key] = value.strip()
+        return result
+
+    # JS joins duplicate headers with commas, except Set-Cookie.
+    for value in js_headers.getSetCookie() or ():
+        result.add_header("Set-Cookie", value.strip())
+    for key, value in js_headers:
+        if key.lower() != "set-cookie":
+            result.add_header(key, value.strip())
+
+    return result