crosswind-workers 0.1.0__py3-none-any.whl

workers/bindings/d1.py

@@ -0,0 +1,47 @@
+from collections.abc import Iterable
+from typing import Any
+
+from ..rpc import python_from_rpc, python_to_rpc
+from .base import Binding, _js_options
+
+__all__ = ["D1Database", "D1PreparedStatement"]
+
+
+class D1PreparedStatement(Binding):
+    def bind(self, *values: Any) -> "D1PreparedStatement":
+        return D1PreparedStatement(self.js_object.bind(*map(python_to_rpc, values)))
+
+    async def first(self, column: str | None = None) -> Any:
+        args = () if column is None else (column,)
+        return python_from_rpc(await self.js_object.first(*args))
+
+    async def all(self) -> dict[str, Any]:
+        return python_from_rpc(await self.js_object.all())
+
+    async def run(self) -> dict[str, Any]:
+        return python_from_rpc(await self.js_object.run())
+
+    async def raw(
+        self,
+        options: Any = None,
+        /,
+        *,
+        column_names: bool | None = None,
+        **extra: Any,
+    ) -> list[list[Any]]:
+        js_options = _js_options(options, extra, column_names=column_names)
+        return python_from_rpc(await self.js_object.raw(js_options))
+
+
+class D1Database(Binding):
+    def prepare(self, query: str) -> D1PreparedStatement:
+        return D1PreparedStatement(self.js_object.prepare(query))
+
+    async def batch(
+        self, statements: Iterable[D1PreparedStatement]
+    ) -> list[dict[str, Any]]:
+        js_statements = python_to_rpc(list(statements))
+        return python_from_rpc(await self.js_object.batch(js_statements))
+
+    async def exec(self, query: str) -> dict[str, Any]:
+        return python_from_rpc(await self.js_object.exec(query))

workers/bindings/env.py

@@ -0,0 +1,50 @@
+"""The env an entrypoint sees, which picks each binding's class."""
+
+from collections.abc import Callable
+from typing import Any
+
+from .._js import js_name
+from ..rpc import python_from_rpc
+from .base import Binding
+from .d1 import D1Database
+from .kv import KVNamespace
+from .queues import Queue
+from .r2 import R2Bucket
+from .services import DurableObjectNamespace, Fetcher
+from .workflow import Workflow
+
+__all__: list[str] = []
+
+_CLASS_FOR_JS: dict[str, Callable[[Any], Any]] = {
+    "Fetcher": Fetcher,
+    "DurableObjectNamespace": DurableObjectNamespace,
+    "WorkflowImpl": Workflow,
+    "KvNamespace": KVNamespace,
+    "R2Bucket": R2Bucket,
+    "D1Database": D1Database,
+    "WorkerQueue": Queue,
+}
+
+
+class _EnvWrapper(Binding):
+    """The env an entrypoint sees: each binding wrapped by its JS class."""
+
+    @property
+    def _env(self) -> Any:
+        # The stock SDK's private name for the JS env, which its tests read.
+        return self.js_object
+
+    def _pass_through(self, name: str, value: Any) -> Any:
+        js_class = js_name(value)
+        if js_class is None:
+            binding = value  # a text var or secret
+        elif js_class in ("Object", "Array"):
+            # A JSON var, or a plain-object binding such as version metadata.
+            binding = python_from_rpc(value)
+        else:
+            binding = _CLASS_FOR_JS.get(js_class, Binding)(value)
+
+        # Bindings don't change, so later reads skip __getattr__.
+        setattr(self, name, binding)
+
+        return binding

workers/bindings/kv.py

@@ -0,0 +1,121 @@
+from typing import Any, Literal, overload
+
+from ..rpc import python_from_rpc, python_to_rpc
+from .base import Binding, _js_options
+
+__all__ = ["KVNamespace"]
+
+type _KVType = Literal["text", "json", "arrayBuffer", "stream"]
+
+
+class KVNamespace(Binding):
+    @overload
+    async def get(
+        self,
+        key: str,
+        type: Literal["text"] = "text",
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> str | None: ...
+    @overload
+    async def get(
+        self,
+        key: str,
+        type: Literal["json"],
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> Any: ...
+    @overload
+    async def get(
+        self,
+        key: str,
+        type: Literal["arrayBuffer"],
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> memoryview | None: ...
+    @overload
+    async def get(
+        self,
+        key: Any,
+        type: str | dict[str, Any] | Any = "text",
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> Any: ...
+    async def get(
+        self,
+        key: Any,
+        type: Any = "text",
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> Any:
+        js_options = _kv_get_options(type, options, cache_ttl)
+        # An arrayBuffer arrives as a memoryview, as in the stock SDK.
+        return python_from_rpc(await self.js_object.get(python_to_rpc(key), js_options))
+
+    async def get_with_metadata(
+        self,
+        key: Any,
+        type: _KVType | dict[str, Any] | Any = "text",
+        /,
+        *,
+        cache_ttl: int | None = None,
+        **options: Any,
+    ) -> dict[str, Any]:
+        js_options = _kv_get_options(type, options, cache_ttl)
+        result = await self.js_object.getWithMetadata(python_to_rpc(key), js_options)
+        return python_from_rpc(result)
+
+    async def put(
+        self,
+        key: str,
+        value: Any,
+        options: Any = None,
+        /,
+        *,
+        expiration: int | None = None,
+        expiration_ttl: int | None = None,
+        metadata: Any = None,
+        **extra: Any,
+    ) -> None:
+        js_options = _js_options(
+            options,
+            extra,
+            expiration=expiration,
+            expiration_ttl=expiration_ttl,
+            metadata=metadata,
+        )
+        await self.js_object.put(key, python_to_rpc(value), js_options)
+
+    async def delete(self, key: str) -> None:
+        await self.js_object.delete(key)
+
+    async def list(
+        self,
+        options: Any = None,
+        /,
+        *,
+        prefix: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        js_options = _js_options(
+            options, extra, prefix=prefix, limit=limit, cursor=cursor
+        )
+        return python_from_rpc(await self.js_object.list(js_options))
+
+
+def _kv_get_options(type: Any, extra: dict[str, Any], cache_ttl: int | None) -> Any:
+    # The second argument is a type name or, as in JS, an options object.
+    given, kv_type = (None, type) if isinstance(type, str) else (type, None)
+    return _js_options(given, extra, type=kv_type, cache_ttl=cache_ttl)

workers/bindings/queues.py

@@ -0,0 +1,36 @@
+from collections.abc import Iterable
+from typing import Any
+
+from ..rpc import python_to_rpc
+from .base import Binding, _js_options
+
+__all__ = ["Queue"]
+
+
+class Queue(Binding):
+    async def send(
+        self,
+        body: Any,
+        options: Any = None,
+        /,
+        *,
+        content_type: str | None = None,
+        delay_seconds: int | None = None,
+        **extra: Any,
+    ) -> None:
+        js_options = _js_options(
+            options, extra, content_type=content_type, delay_seconds=delay_seconds
+        )
+        await self.js_object.send(python_to_rpc(body), js_options)
+
+    async def send_batch(
+        self,
+        messages: Iterable[dict[str, Any]],
+        options: Any = None,
+        /,
+        *,
+        delay_seconds: int | None = None,
+        **extra: Any,
+    ) -> None:
+        js_options = _js_options(options, extra, delay_seconds=delay_seconds)
+        await self.js_object.sendBatch(python_to_rpc(list(messages)), js_options)

workers/bindings/r2.py

@@ -0,0 +1,130 @@
+from collections.abc import Iterable
+from typing import Any
+
+from ..rpc import python_from_rpc, python_to_rpc
+from .base import Binding, _js_options
+
+__all__ = ["R2Bucket", "R2Object", "R2ObjectBody"]
+
+
+class R2Object(Binding):
+    @property
+    def key(self) -> str:
+        return self.js_object.key
+
+    @property
+    def version(self) -> str:
+        return self.js_object.version
+
+    @property
+    def size(self) -> int:
+        return self.js_object.size
+
+    @property
+    def etag(self) -> str:
+        return self.js_object.etag
+
+    @property
+    def http_etag(self) -> str:
+        return self.js_object.httpEtag
+
+    @property
+    def uploaded(self) -> Any:
+        return python_from_rpc(self.js_object.uploaded)
+
+    @property
+    def http_metadata(self) -> dict[str, Any]:
+        return python_from_rpc(self.js_object.httpMetadata)
+
+    @property
+    def custom_metadata(self) -> dict[str, str]:
+        return python_from_rpc(self.js_object.customMetadata)
+
+
+class R2ObjectBody(R2Object):
+    @property
+    def body(self) -> Any:
+        return self.js_object.body
+
+    @property
+    def body_used(self) -> bool:
+        return self.js_object.bodyUsed
+
+    async def text(self) -> str:
+        return await self.js_object.text()
+
+    async def bytes(self) -> bytes:
+        return (await self.js_object.arrayBuffer()).to_bytes()
+
+    async def json(self) -> Any:
+        return python_from_rpc(await self.js_object.json())
+
+
+def _r2_object(value: Any) -> Any:
+    value = python_from_rpc(value)
+    if value is None:
+        return None
+    return R2ObjectBody(value) if hasattr(value, "body") else R2Object(value)
+
+
+class R2Bucket(Binding):
+    async def head(self, key: str) -> R2Object | None:
+        return _r2_object(await self.js_object.head(key))
+
+    async def get(
+        self, key: str, options: Any = None, /, **extra: Any
+    ) -> R2ObjectBody | R2Object | None:
+        # An R2Object without a body when an onlyIf condition fails.
+        js_options = _js_options(options, extra)
+        return _r2_object(await self.js_object.get(key, js_options))
+
+    async def put(
+        self,
+        key: str,
+        value: Any,
+        options: Any = None,
+        /,
+        *,
+        http_metadata: dict[str, Any] | None = None,
+        custom_metadata: dict[str, str] | None = None,
+        **extra: Any,
+    ) -> R2Object | None:
+        js_options = _js_options(
+            options,
+            extra,
+            http_metadata=http_metadata,
+            custom_metadata=custom_metadata,
+        )
+        return _r2_object(
+            await self.js_object.put(key, python_to_rpc(value), js_options)
+        )
+
+    async def delete(self, keys: str | Iterable[str]) -> None:
+        await self.js_object.delete(
+            keys if isinstance(keys, str) else python_to_rpc(list(keys))
+        )
+
+    async def list(
+        self,
+        options: Any = None,
+        /,
+        *,
+        prefix: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        delimiter: str | None = None,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        js_options = _js_options(
+            options,
+            extra,
+            prefix=prefix,
+            limit=limit,
+            cursor=cursor,
+            delimiter=delimiter,
+        )
+
+        listing = python_from_rpc(await self.js_object.list(js_options))
+        listing["objects"] = [R2Object(item) for item in listing.get("objects", [])]
+
+        return listing

workers/bindings/services.py

@@ -0,0 +1,55 @@
+"""Service bindings, the assets binding and Durable Object namespaces."""
+
+from typing import Any
+
+from ..fetch import fetch
+from ..response import Response
+from .base import Binding, _js_options
+
+__all__ = ["DurableObjectNamespace", "Fetcher"]
+
+
+class Fetcher(Binding):
+    """A service binding, the assets binding, or a Durable Object stub.
+
+    `fetch` returns a crosswind Response. RPC methods pass through.
+    """
+
+    async def fetch(self, input: Any, **options: Any) -> Response:
+        return await fetch(input, fetcher=self.js_object.fetch, **options)
+
+
+def _stub(js_stub: Any) -> Any:
+    # Callers type it as the Durable Object class, which no Python type can
+    # say of a stub (decisions.md#typed-bindings).
+    return Fetcher(js_stub)
+
+
+class DurableObjectNamespace[T](Binding):
+    """Names this class doesn't define come back raw, as in the stock SDK, so
+    a Durable Object id from `idFromName` stays a JS id."""
+
+    def _pass_through(self, name: str, value: Any) -> Any:
+        return value
+
+    def id_from_name(self, name: str) -> Any:
+        return self.js_object.idFromName(name)
+
+    def id_from_string(self, id: str) -> Any:
+        return self.js_object.idFromString(id)
+
+    def new_unique_id(self, options: Any = None, /, **extra: Any) -> Any:
+        return self.js_object.newUniqueId(_js_options(options, extra))
+
+    def get(self, id: Any, options: Any = None, /, **extra: Any) -> T:
+        return _stub(self.js_object.get(id, _js_options(options, extra)))
+
+    def get_by_name(self, name: str, options: Any = None, /, **extra: Any) -> T:
+        return _stub(self.js_object.getByName(name, _js_options(options, extra)))
+
+    def getByName(self, name: str, *args: Any, **kwargs: Any) -> T:  # noqa: N802
+        # The stock SDK's name, which also returns a stub with a Python fetch.
+        return _stub(self.js_object.getByName(name, *args, **kwargs))
+
+    def jurisdiction(self, name: str) -> "DurableObjectNamespace[T]":
+        return DurableObjectNamespace(self.js_object.jurisdiction(name))

workers/bindings/workflow.py

@@ -0,0 +1,64 @@
+"""The Workflow binding, which starts and controls instances. The Workflow
+code itself lives in `workers.workflows`."""
+
+from collections.abc import Iterable
+from typing import Any
+
+from ..rpc import python_from_rpc, python_to_rpc
+from .base import Binding, _js_options
+
+__all__ = ["Workflow", "WorkflowInstance"]
+
+
+class WorkflowInstance(Binding):
+    @property
+    def id(self) -> str:
+        return self.js_object.id
+
+    async def status(self) -> dict[str, Any]:
+        return python_from_rpc(await self.js_object.status())
+
+    async def pause(self) -> None:
+        await self.js_object.pause()
+
+    async def resume(self) -> None:
+        await self.js_object.resume()
+
+    async def restart(self) -> None:
+        await self.js_object.restart()
+
+    async def terminate(self) -> None:
+        await self.js_object.terminate()
+
+    async def send_event(
+        self,
+        event: Any = None,
+        /,
+        *,
+        type: str | None = None,
+        payload: Any = None,
+        **extra: Any,
+    ) -> None:
+        js_event = _js_options(event, extra, type=type, payload=payload)
+        await self.js_object.sendEvent(js_event)
+
+
+class Workflow(Binding):
+    async def get(self, id: str) -> WorkflowInstance:
+        return WorkflowInstance(await self.js_object.get(id))
+
+    async def create(
+        self,
+        options: Any = None,
+        /,
+        *,
+        id: str | None = None,
+        params: Any = None,
+        **extra: Any,
+    ) -> WorkflowInstance:
+        js_options = _js_options(options, extra, id=id, params=params)
+        return WorkflowInstance(await self.js_object.create(js_options))
+
+    async def create_batch(self, batch: Iterable[Any]) -> list[WorkflowInstance]:
+        instances = await self.js_object.createBatch(python_to_rpc(list(batch)))
+        return [WorkflowInstance(instance) for instance in instances]

workers/blob.py

@@ -0,0 +1,158 @@
+from collections.abc import Generator, Iterable
+from contextlib import ExitStack, contextmanager
+from enum import StrEnum
+from typing import Any
+
+import js
+from pyodide.ffi import to_js
+
+from ._js import js_name, lend_buffer, managed_pyproxies
+
+__all__ = ["Blob", "BlobEnding", "BlobValue", "File"]
+
+type BlobValue = (
+    str | bytes | js.ArrayBuffer | js.TypedArray | js.DataView | js.Blob | Blob | File
+)
+
+
+class BlobEnding(StrEnum):
+    TRANSPARENT = "transparent"
+    NATIVE = "native"
+
+
+class Blob:
+    def __init__(
+        self,
+        blob_parts: Iterable[BlobValue] | BlobValue,
+        content_type: str | None = None,
+        endings: BlobEnding | str | None = None,
+    ) -> None:
+        if not _is_part_list(blob_parts):
+            # A single Blob or File passes on its type. A File's name is lost.
+            if not content_type:
+                content_type = _blob_type(blob_parts)
+            blob_parts = [blob_parts]
+
+        with _js_parts(blob_parts) as parts:
+            self._js_blob = js.Blob.new(
+                parts, type=content_type, endings=str(endings) if endings else None
+            )
+
+    @property
+    def size(self) -> int:
+        return self._js_blob.size
+
+    @property
+    def content_type(self) -> str:
+        return self._js_blob.type
+
+    @property
+    def js_object(self) -> "js.Blob":
+        return self._js_blob
+
+    async def text(self) -> str:
+        return await self.js_object.text()
+
+    async def bytes(self) -> bytes:
+        return (await self.js_object.arrayBuffer()).to_bytes()
+
+    def slice(
+        self,
+        start: int | None = None,
+        end: int | None = None,
+        content_type: str | None = None,
+    ) -> "Blob":
+        return Blob([self.js_object.slice(start, end, content_type)])
+
+
+class File(Blob):
+    def __init__(
+        self,
+        blob_parts: Iterable[BlobValue] | BlobValue,
+        filename: str | None = None,
+        content_type: str | None = None,
+        endings: BlobEnding | str | None = None,
+        last_modified: int | None = None,
+    ) -> None:
+        if not _is_part_list(blob_parts):
+            # A single Blob or File passes on its type, and a File its name and
+            # time, so a JS File received over RPC wraps without a filename.
+            if not content_type:
+                content_type = _blob_type(blob_parts)
+            source: Any = blob_parts
+            if isinstance(source, File):
+                source = source.js_object
+            if js_name(source) == "File":
+                filename = source.name if filename is None else filename
+                last_modified = last_modified or source.lastModified
+            blob_parts = [blob_parts]
+
+        if filename is None:
+            raise TypeError("File() needs a filename unless it wraps a single File")
+
+        with _js_parts(blob_parts) as parts:
+            self._js_blob = js.File.new(
+                parts,
+                filename,
+                type=content_type,
+                endings=str(endings) if endings else None,
+                lastModified=last_modified,
+            )
+
+    @property
+    def name(self) -> str:
+        return self._js_blob.name
+
+    @property
+    def last_modified(self) -> int:
+        return self._js_blob.lastModified
+
+
+def _is_part_list(parts: Any) -> bool:
+    # bytes-like values are one part, even though Python can iterate them.
+    if isinstance(parts, (str, bytes, bytearray, memoryview)):
+        return False
+
+    try:
+        iter(parts)
+    except TypeError:
+        return False
+
+    return True
+
+
+def _blob_type(part: Any) -> str | None:
+    if isinstance(part, Blob):
+        return part.content_type
+    if js_name(part) in ("Blob", "File"):
+        return part.type
+    return None
+
+
+@contextmanager
+def _js_parts(parts: Any) -> Generator[Any]:
+    with ExitStack() as stack:
+        entries = [stack.enter_context(_js_part(part)) for part in parts]
+        with managed_pyproxies() as pyproxies:
+            yield to_js(entries, pyproxies=pyproxies)
+
+
+@contextmanager
+def _js_part(part: Any) -> Generator[Any]:
+    if isinstance(part, str) or js_name(part) in ("Blob", "File"):
+        yield part
+    elif isinstance(part, Blob):
+        yield part.js_object
+    elif _is_buffer(part):
+        with lend_buffer(part) as view:
+            yield view
+    else:
+        raise TypeError(f"Don't know how to handle {type(part)} for Blob()")
+
+
+def _is_buffer(value: Any) -> bool:
+    try:
+        with memoryview(value):
+            return True
+    except TypeError:
+        return False