crosswind-workers 0.1.0__py3-none-any.whl

workers/response.py

@@ -0,0 +1,181 @@
+import json
+from collections.abc import Callable, Coroutine
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any, overload
+
+import js
+import pyodide.http
+from pyodide.ffi import JsProxy
+
+from ._body import BodyMixin
+from ._js import js_body, js_name, none_if_null, python_errors, to_js_headers
+from .blob import Blob
+from .formdata import FormData
+
+if TYPE_CHECKING:
+    from .types import Body, Headers
+
+__all__ = ["RESPONSE_ACCEPTED_TYPES", "FetchResponse", "Response"]
+
+# The JS body types js.Response accepts.
+RESPONSE_ACCEPTED_TYPES = {
+    "Blob",
+    "ArrayBuffer",
+    "TypedArray",
+    "DataView",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int8Array",
+    "Uint16Array",
+    "Int16Array",
+    "Uint32Array",
+    "Int32Array",
+    "Float16Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+    "FormData",
+    "ReadableStream",
+    "URLSearchParams",
+    "Response",
+}
+
+
+class _Json:
+    """Response.json(data) is from_json; response.json() parses the body.
+
+    The stock SDK does this inside one method, which a type checker can't
+    follow. A descriptor gives each use its own signature.
+    """
+
+    @overload
+    def __get__(self, instance: None, owner: type) -> Callable[..., "Response"]: ...
+    @overload
+    def __get__(
+        self, instance: "FetchResponse", owner: type
+    ) -> Callable[..., Coroutine[Any, Any, Any]]: ...
+    def __get__(self, instance: "FetchResponse | None", owner: type) -> Any:
+        if instance is None:
+            return _stock_json
+        return lambda *args, **kwargs: _stock_json(instance, *args, **kwargs)
+
+
+def _stock_json(data: Any, *args: Any, **kwargs: Any) -> Any:
+    # The stock SDK's one method: a Response's body parse, else from_json.
+    if isinstance(data, Response):
+        return pyodide.http.FetchResponse.json(data)
+    return FetchResponse.from_json(data, *args, **kwargs)
+
+
+class FetchResponse(BodyMixin, pyodide.http.FetchResponse):
+    @property
+    def body(self) -> "js.ReadableStream | None":
+        return none_if_null(self.js_object.body)
+
+    @property
+    def js_object(self) -> "js.Response":
+        return self.js_response
+
+    async def formData(self) -> FormData:  # noqa: N802 (the stock SDK's alias)
+        return await self.form_data()
+
+    def replace_body(self, body: "Body") -> "Response":
+        """A new Response with this one's status and headers and a new body."""
+        with js_body(body) as converted:
+            return Response(js.Response.new(converted, self.js_response))
+
+    @staticmethod
+    def redirect(url: str, status: HTTPStatus | int = HTTPStatus.FOUND) -> "Response":
+        # The stock SDK returns the raw JS Response here.
+        with python_errors():
+            return Response(js.Response.redirect(url, int(status)))
+
+    @staticmethod
+    def from_json(
+        data: Any,
+        status: HTTPStatus | int = HTTPStatus.OK,
+        status_text: str = "",
+        headers: "Headers | None" = None,
+    ) -> "Response":
+        options = Response._create_options(status, status_text, headers)
+
+        with python_errors():
+            if isinstance(data, JsProxy):
+                return Response(js.Response.json(data, **options))
+
+            if "headers" not in options:
+                options["headers"] = to_js_headers({"content-type": "application/json"})
+            elif not options["headers"].has("content-type"):
+                options["headers"].set("content-type", "application/json")
+
+            return Response(js.Response.new(json.dumps(data), **options))
+
+    # A descriptor where Pyodide has a method, so ty reports the override.
+    json = _Json()  # ty: ignore[invalid-attribute-override]
+
+
+class Response(FetchResponse):
+    """An HTTP response, with an API like the web's Response."""
+
+    def __init__(
+        self,
+        body: "Body" = None,
+        status: HTTPStatus | int | None = None,
+        status_text: str = "",
+        headers: "Headers | None" = None,
+        web_socket: "js.WebSocket | None" = None,
+    ) -> None:
+        name = js_name(body)
+        if name is not None:
+            if name not in RESPONSE_ACCEPTED_TYPES:
+                raise TypeError(f"Unsupported type in Response: {name}")
+        elif not isinstance(body, (str, bytes, FormData, Blob)) and body is not None:
+            # The stock SDK also rejects a Blob.
+            raise TypeError(f"Unsupported type in Response: {type(body).__name__}")
+
+        if name == "Response":
+            if status is not None or status_text or headers is not None:
+                raise ValueError(
+                    "Expected no options when constructing Response from a js.Response"
+                )
+            js_response: Any = body
+            super().__init__(js_response.url, js_response)
+            return
+
+        options = self._create_options(status, status_text, headers, web_socket)
+        with js_body(body) as converted:
+            js_response = js.Response.new(converted, **options)
+        super().__init__(js_response.url, js_response)
+
+    def __repr__(self) -> str:
+        parts = [f"status={self.status}"]
+        if self.js_object.statusText:
+            parts.append(f"status_text={self.status_text!r}")
+        if "content-type" in self.headers:
+            parts.append(f"content_type={self.headers['content-type']!r}")
+        if self.js_object.url:
+            parts.append(f"url={self.js_object.url!r}")
+        if self.js_object.type != "default":
+            parts.append(f"type={self.js_object.type!r}")
+
+        return f"Response({', '.join(parts)})"
+
+    @staticmethod
+    def _create_options(
+        status: HTTPStatus | int | None = HTTPStatus.OK,
+        status_text: str = "",
+        headers: "Headers | None" = None,
+        web_socket: "js.WebSocket | None" = None,
+    ) -> dict[str, Any]:
+        options: dict[str, Any] = {}
+        if status:
+            options["status"] = int(status)
+        if status_text:
+            options["statusText"] = status_text
+        if headers:
+            options["headers"] = to_js_headers(headers)
+        if web_socket:
+            options["webSocket"] = web_socket
+
+        return options

workers/rpc.py

@@ -0,0 +1,154 @@
+import datetime
+import inspect
+from typing import Any
+
+import js
+from pyodide.ffi import create_proxy, to_js
+
+from ._js import js_name, jsnull
+from .blob import Blob, File
+from .formdata import FormData
+from .request import Request
+from .response import Response
+
+__all__ = ["JsDict", "python_from_rpc", "python_to_rpc"]
+
+
+def python_from_rpc(obj: Any) -> Any:
+    """Convert a value workerd received over RPC to Python, as the stock SDK does."""
+    if obj is jsnull:
+        return None
+
+    name = js_name(obj)
+    if name is None:
+        return obj
+    if name == "TestController":
+        return None
+
+    return _null_to_none(obj.to_py(default_converter=_default_from_js))
+
+
+def python_to_rpc(value: Any) -> Any:
+    """Convert a Python value to send over RPC, as the stock SDK does."""
+    value = _none_to_null(value)
+    if value is jsnull:
+        return value
+
+    # to_js converts some containers without asking the default converter.
+    _refuse_unsendable(value)
+    return to_js(
+        value, default_converter=_default_to_js, dict_converter=js.Object.fromEntries
+    )
+
+
+class JsDict(dict):
+    """A dict received over RPC, whose keys also read as attributes."""
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        self[name] = value
+
+
+_PYTHON_TWINS = {
+    "Response": Response,
+    "Request": Request,
+    "FormData": FormData,
+    "Blob": Blob,
+    "File": File,
+    "Date": lambda date: datetime.datetime.fromtimestamp(date.getTime() / 1000),
+    "Error": lambda error: Exception(error.toString()),
+    "Number": lambda number: number.valueOf(),
+}
+
+
+def _default_from_js(value: Any, converter: Any, cache: Any) -> Any:
+    if value is jsnull:
+        return None
+    twin = _PYTHON_TWINS.get(js_name(value) or "")
+    return twin(value) if twin else value
+
+
+def _null_to_none(value: Any) -> Any:
+    if value is jsnull:
+        return None
+    if isinstance(value, dict):
+        return JsDict({k: _null_to_none(v) for k, v in value.items()})
+    if isinstance(value, list):
+        return [_null_to_none(v) for v in value]
+    return value
+
+
+def _none_to_null(value: Any) -> Any:
+    if value is None:
+        return jsnull
+    if isinstance(value, dict):
+        return {k: _none_to_null(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_none_to_null(v) for v in value]
+    return value
+
+
+def _refuse_unsendable(value: Any) -> None:
+    # A wrapper is sent as its JS object, and callables as proxies.
+    if hasattr(value, "js_object") or (callable(value) and not isinstance(value, type)):
+        return
+
+    if js_name(value) == "RegExp":
+        raise TypeError(f"{value.constructor.name} cannot be sent over RPC.")
+    if isinstance(value, (tuple, bytearray)):
+        raise TypeError(f"{type(value)} cannot be sent over RPC.")
+    if inspect.isawaitable(value):
+        raise TypeError(f"Awaitable {type(value)} cannot be sent over RPC.")
+    if isinstance(value, (str, bytes)):
+        return
+
+    try:
+        items = iter(value.values() if isinstance(value, dict) else value)
+    except TypeError:
+        return
+
+    # Iterating an iterator such as a generator would empty it before it is
+    # sent, which the stock SDK does. A container gives a fresh iterator.
+    if items is value:
+        return
+    for item in items:
+        _refuse_unsendable(item)
+
+
+def _default_to_js(value: Any, converter: Any, cache: Any) -> Any:
+    if hasattr(value, "js_object"):
+        return value.js_object
+    if isinstance(value, datetime.datetime):
+        return js.Date.new(value.timestamp() * 1000)
+    if isinstance(value, Exception):
+        return js.Error.new(str(value))
+    if callable(value) and not isinstance(value, type):
+        # A persistent proxy, so the receiver can call it after this returns.
+        return create_proxy(value)
+
+    _refuse_unsendable(value)
+    return value
+
+
+# The stock SDK's private wrapper names, which its own tests import from here,
+# and the crosswind classes that play their parts.
+_STOCK_PRIVATE_NAMES = {
+    "_BindingWrapper": "Binding",
+    "_EnvWrapper": "_EnvWrapper",
+    "_FetcherWrapper": "Fetcher",
+    "_RpcStubWrapper": "_RpcStub",
+}
+
+
+def __getattr__(name: str) -> Any:
+    # Served lazily, because bindings imports this module.
+    if name in _STOCK_PRIVATE_NAMES:
+        from . import bindings
+
+        return getattr(bindings, _STOCK_PRIVATE_NAMES[name])
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

workers/types.py

@@ -0,0 +1,57 @@
+from collections.abc import Awaitable
+from http import HTTPMethod
+from typing import TYPE_CHECKING, Any, Protocol, TypedDict
+
+if TYPE_CHECKING:
+    import js
+    from pyodide.ffi import JsBuffer
+
+    from .blob import Blob
+    from .formdata import FormData
+
+__all__ = [
+    "Body",
+    "Context",
+    "FetchKwargs",
+    "Headers",
+    "JSBody",
+    "RequestInitCfProperties",
+]
+
+
+class Context(Protocol):
+    def waitUntil(self, other: Awaitable[Any]) -> None: ...  # noqa: N802
+
+
+type JSBody = js.Blob | JsBuffer | js.FormData | js.ReadableStream | js.URLSearchParams
+type Body = str | bytes | FormData | Blob | JSBody | None
+type Headers = dict[str, str] | list[tuple[str, str]] | js.Headers
+
+
+class RequestInitCfProperties(TypedDict, total=False):
+    """https://developers.cloudflare.com/workers/runtime-apis/request/#the-cf-property-requestinitcfproperties"""
+
+    apps: bool | None
+    cacheEverything: bool | None
+    cacheKey: str | None
+    cacheTags: list[str] | None
+    cacheTtl: int
+    cacheTtlByStatus: dict[str, int]
+    image: Any | None
+    mirage: bool | None
+    polish: str | None
+    resolveOverride: str | None
+    scrapeShield: bool | None
+    webp: bool | None
+
+
+class FetchKwargs(TypedDict, total=False):
+    """https://developers.cloudflare.com/workers/runtime-apis/request/#options"""
+
+    headers: "Headers | None"
+    body: "Body | None"
+    method: HTTPMethod | str | None
+    redirect: str | None
+    cf: RequestInitCfProperties | None
+    # A JS fetch function, such as a service binding's.
+    fetcher: Any

workers/utils.py

@@ -0,0 +1,55 @@
+"""Module-level helpers with the stock SDK's names and import paths."""
+
+from typing import Any, NoReturn
+
+import _pyodide_entrypoint_helper
+from pyodide.ffi import JsException
+
+__all__ = ["import_from_javascript", "patch_env"]
+
+# JS modules workerd imports ahead of time, by the helper attribute holding each.
+_PRELOADED = {
+    "cloudflare:workers": "cloudflareWorkersModule",
+    "cloudflare:sockets": "cloudflareSocketsModule",
+}
+
+
+def import_from_javascript(module_name: str) -> Any:
+    """Import a JS module, such as "cloudflare:sockets", from Python.
+
+    "cloudflare:workers" and "cloudflare:sockets" are imported ahead of time,
+    so they work everywhere. Any other module goes through run_sync, which
+    Python 3.12 Workers lack. On 3.13 and 3.14 it works at top level too.
+    """
+    if module_name in _PRELOADED:
+        return getattr(_pyodide_entrypoint_helper, _PRELOADED[module_name])
+
+    failed = f"Failed to import '{module_name}'"
+    try:
+        from pyodide.ffi import run_sync
+    except ImportError as error:
+        raise ImportError(
+            f"{failed}: Only 'cloudflare:workers' and 'cloudflare:sockets' are "
+            "available until the next python runtime version."
+        ) from error
+
+    try:
+        return run_sync(_pyodide_entrypoint_helper.doAnImport(module_name))
+    except JsException as error:
+        raise ImportError(f"{failed}: {error}") from error
+    except RuntimeError as error:
+        if error.args and error.args[0] == "No suspender":
+            raise ImportError(
+                f"{failed}: Only 'cloudflare:workers' and 'cloudflare:sockets' "
+                "are available in the global scope."
+            ) from error
+        raise
+
+
+def patch_env(*args: Any, **kwargs: Any) -> NoReturn:
+    """Removed from workerd. The stock SDK still exports it, so crosswind does."""
+    raise NotImplementedError(
+        "patch_env needs a workerd helper that workerd removed on 2026-06-30 "
+        "(commit 6581cf0), so it can't swap env. Pass the values you need "
+        "explicitly instead."
+    )