workers-runtime-sdk 1.6.2__tar.gz → 1.6.4__tar.gz

{workers_runtime_sdk-1.6.2 → workers_runtime_sdk-1.6.4}/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 <!-- version list -->
 
+## v1.6.4 (2026-07-30)
+
+### Bug Fixes
+
+- **runtime-sdk**: Deliver client WebSocket close events to the ASGI app
+  ([#158](https://github.com/cloudflare/workers-py/pull/158),
+  [`6f53155`](https://github.com/cloudflare/workers-py/commit/6f53155b5620137c749a64dc4ee785505cede74e))
+
+- **runtime-sdk**: Register the WebSocket close handler on onclose
+  ([#158](https://github.com/cloudflare/workers-py/pull/158),
+  [`6f53155`](https://github.com/cloudflare/workers-py/commit/6f53155b5620137c749a64dc4ee785505cede74e))
+
+- **runtime-sdk**: Surface client closes as websocket.disconnect
+  ([#158](https://github.com/cloudflare/workers-py/pull/158),
+  [`6f53155`](https://github.com/cloudflare/workers-py/commit/6f53155b5620137c749a64dc4ee785505cede74e))
+
+
+## v1.6.3 (2026-07-17)
+
+### Bug Fixes
+
+- Wrap AnalyticsEngine, which is used in production
+  ([#155](https://github.com/cloudflare/workers-py/pull/155),
+  [`91e4e50`](https://github.com/cloudflare/workers-py/commit/91e4e500ddfe849cae0bd75481e0e62ff01de97d))
+
+
 ## v1.6.2 (2026-07-09)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.2 → workers_runtime_sdk-1.6.4}/PKG-INFO

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

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

{workers_runtime_sdk-1.6.2 → workers_runtime_sdk-1.6.4}/src/asgi.py

@@ -300,7 +300,10 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
     onopen(1)
 
     def onclose(evt):
-        msg = {"type": "websocket.close", "code": evt.code, "reason": evt.reason}
+        # Client-initiated closes surface to the app as "websocket.disconnect"
+        # per the ASGI spec ("websocket.close" is the app->server direction);
+        # frameworks raise their disconnect exceptions only on this type.
+        msg = {"type": "websocket.disconnect", "code": evt.code, "reason": evt.reason}
         queue.put_nowait(msg)
 
     def onmessage(evt):
@@ -308,7 +311,7 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
         queue.put_nowait(msg)
 
     server.onopen = onopen
-    server.onopen = onclose
+    server.onclose = onclose
     server.onmessage = onmessage
 
     async def ws_send(got):

{workers_runtime_sdk-1.6.2 → workers_runtime_sdk-1.6.4}/src/workers/__init__.py

@@ -1,16 +1,15 @@
-from ._workers import (
+from .blob import Blob, BlobEnding, BlobValue, File
+from .entrypoints import (
     DurableObject,
     WorkerEntrypoint,
     WorkflowEntrypoint,
-    _EnvWrapper,
     handler,
 )
-from .blob import Blob, BlobEnding, BlobValue, File
 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 .rpc import _EnvWrapper, python_from_rpc, python_to_rpc
 from .types import (
     Body,
     Context,

workers_runtime_sdk-1.6.2/src/workers/_workers.py → workers_runtime_sdk-1.6.4/src/workers/entrypoints.py

@@ -1,172 +1,28 @@
-# This module defines a Workers API for Python. It is similar to the API provided by
-# JS Workers, but with changes and additions to be more idiomatic to the Python
-# programming language.
 import functools
 import inspect
 from asyncio import create_task, gather
 from typing import TYPE_CHECKING, Any
 
 import _cloudflare_compat_flags
-
-# Get globals modules and import function from the entrypoint-helper
 import _pyodide_entrypoint_helper
 import js
 from js import Object
-from pyodide.ffi import (
-    JsProxy,
-    create_once_callable,
-    to_js,
-)
+from pyodide.ffi import create_once_callable, to_js
 
-from .fetch import fetch
 from .request import Request
-from .rpc import python_from_rpc, python_to_rpc
-from .utils import (
-    _JS_PASSTHROUGH_TYPES,
-    _from_js_error,
-    _get_js_constructor_name,
-    _is_js_instance,
+from .rpc import (
+    _BindingWrapper,
+    _EnvWrapper,
+    _idempotent_new,
+    python_from_rpc,
+    python_to_rpc,
 )
+from .utils import _from_js_error, _is_js_instance
 
 if TYPE_CHECKING:
     from js import DurableObjectState, Env, ExecutionContext
 
 
-def _idempotent_new(cls, obj):
-    """Set __new__ on a class to this so cls is idempotent:
-
-    >>> a = A(x)
-    >>> b = A(a)
-    >>> assert a is b
-
-    For this to work, start the __init__ function with:
-
-    if obj is self:
-        return
-
-    to prevent double-init.
-    """
-    if isinstance(obj, cls):
-        return obj
-    return object.__new__(cls)
-
-
-class _BindingWrapper:
-    __new__ = _idempotent_new
-
-    def __init__(self, binding):
-        if binding is self:
-            return
-        self._binding = binding
-
-    @property
-    def _real_name(self):
-        js_name = _get_js_constructor_name(self._binding)
-        if not js_name:
-            # Should not happen, but just in case
-            return type(self).__name__
-        return js_name
-
-    def _should_wrap_nested_attribute(self, jsobj) -> bool:
-        if not isinstance(jsobj, JsProxy):
-            return False
-
-        # TODO: This allowlist approach is a workaround. The long-term fix is to
-        # add dedicated Python wrappers for these types in python_from_rpc so they
-        # never reach _BindingWrapper in the first place.
-        js_type = _get_js_constructor_name(jsobj)
-        return js_type and js_type not in _JS_PASSTHROUGH_TYPES
-
-    def _convert_result(self, result):
-        converted = python_from_rpc(result)
-
-        # After python_from_rpc, some objects may still be JsProxy objects.
-        # We need to wrap them with _BindingWrapper (or a subclass of it) again
-        # to ensure that accessing attributes on them will be properly converted.
-        if self._should_wrap_nested_attribute(converted):
-            return self.__class__(converted)
-        if isinstance(converted, list):
-            return [
-                self.__class__(item)
-                if self._should_wrap_nested_attribute(item)
-                else item
-                for item in converted
-            ]
-        return converted
-
-    @staticmethod
-    def _convert_args(args, kwargs):
-        js_args = [python_to_rpc(arg) for arg in args]
-        js_kwargs = {k: python_to_rpc(v) for k, v in kwargs.items()}
-        return js_args, js_kwargs
-
-    def _getattr_helper(self, name):
-        attr = getattr(self._binding, name)
-
-        if not callable(attr):
-            return self._convert_result(attr)
-
-        def wrapper(*args, **kwargs):
-            js_args, js_kwargs = self._convert_args(args, kwargs)
-            result = attr(*js_args, **js_kwargs)
-            if hasattr(result, "then") and callable(result.then):
-
-                async def await_and_convert():
-                    return self._convert_result(await result)
-
-                return await_and_convert()
-            return self._convert_result(result)
-
-        return wrapper
-
-    def __getattr__(self, name):
-        result = self._getattr_helper(name)
-        setattr(self, name, result)
-        return result
-
-    def __getitem__(self, key):
-        if isinstance(key, int):
-            return self._convert_result(self._binding[key])
-        return self._convert_result(getattr(self._binding, key))
-
-    def __iter__(self):
-        binding = self._binding
-        if not hasattr(binding, "__iter__"):
-            raise TypeError(f"'{self._real_name}' object is not iterable")
-        for item in binding:
-            yield self._convert_result(item)
-
-    def __len__(self):
-        binding = self._binding
-        if not hasattr(binding, "length"):
-            raise TypeError(f"'{self._real_name}' object has no len()")
-        return binding.length
-
-
-class _FetcherWrapper(_BindingWrapper):
-    def fetch(self, *args, **kwargs):
-        return fetch(*args, fetcher=self._binding.fetch, **kwargs)
-
-
-class _DurableObjectNamespaceWrapper:
-    def __init__(self, binding):
-        self._binding = binding
-
-    def __getattr__(self, name):
-        return getattr(self._binding, name)
-
-    def get(self, *args, **kwargs):
-        return _FetcherWrapper(self._binding.get(*args, **kwargs))
-
-    def getByName(self, *args, **kwargs):
-        return _FetcherWrapper(self._binding.getByName(*args, **kwargs))
-
-    def jurisdiction(self, *args, **kwargs):
-        return _DurableObjectNamespaceWrapper(
-            self._binding.jurisdiction(*args, **kwargs)
-        )
-
-
 class DurableObjectAbort(BaseException):
     pass
 
@@ -212,103 +68,6 @@ class DurableObjectContext:
         raise DurableObjectAbort(reason or "Durable Object abort requested")
 
 
-class _WorkflowInstanceWrapper(_BindingWrapper):
-    # status/pause/resume/restart/terminate share their JS names and are handled by
-    # the _BindingWrapper, which already converts arguments and results.
-    # Only send_event needs the snake_case -> camelCase mapping for backward compatibility
-
-    async def send_event(self, *args, **kwargs):
-        js_args, js_kwargs = self._convert_args(args, kwargs)
-        return self._convert_result(
-            await self._binding.sendEvent(*js_args, **js_kwargs)
-        )
-
-
-class _WorkflowBindingWrapper(_BindingWrapper):
-    async def get(self, *args, **kwargs):
-        js_args, js_kwargs = self._convert_args(args, kwargs)
-        return _WorkflowInstanceWrapper(await self._binding.get(*js_args, **js_kwargs))
-
-    async def create(self, *args, **kwargs):
-        js_args, js_kwargs = self._convert_args(args, kwargs)
-        return _WorkflowInstanceWrapper(
-            await self._binding.create(*js_args, **js_kwargs)
-        )
-
-    async def create_batch(self, *args, **kwargs):
-        js_args, js_kwargs = self._convert_args(args, kwargs)
-        return [
-            _WorkflowInstanceWrapper(w)
-            for w in await self._binding.createBatch(*js_args, **js_kwargs)
-        ]
-
-
-class _EnvWrapper:
-    _BINDING_TYPES = {
-        "KvNamespace",
-        "R2Bucket",
-        "D1Database",
-        "WorkerQueue",
-        "Ai",
-        "VectorizeIndexImpl",
-        "AnalyticsEngineDataset",
-        "LocalAnalyticsEngineDataset",
-        "ImagesBindingImpl",
-        "HostedImagesBindingImpl",
-        "Ratelimit",
-    }
-
-    __new__ = _idempotent_new
-
-    def __init__(self, env: Any):
-        if env is self:
-            return
-        self._env = env
-
-    def _getattr_helper(self, name):
-        binding = getattr(self._env, name)
-        if _is_js_instance(binding, "Fetcher"):
-            return _FetcherWrapper(binding)
-
-        if _is_js_instance(binding, "DurableObjectNamespace"):
-            return _DurableObjectNamespaceWrapper(binding)
-
-        if _is_js_instance(binding, "WorkflowImpl"):
-            return _WorkflowBindingWrapper(binding)
-
-        if _is_js_instance(binding, self._BINDING_TYPES):
-            return _BindingWrapper(binding)
-
-        return binding
-
-    def __getattr__(self, name):
-        result = self._getattr_helper(name)
-        setattr(self, name, result)
-        return result
-
-
-def handler(func):
-    """
-    When applied to handlers such as `on_fetch` it will rewrite arguments passed in to native Python
-    types defined in this module. For example, the `request` argument to `on_fetch` gets converted
-    to an instance of the Request class defined in this module.
-    """
-
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        # TODO: support transforming kwargs
-        if len(args) > 0 and _is_js_instance(args[0], "Request"):
-            args = (Request(args[0]), *args[1:])
-
-        # Wrap `env` so that bindings can be used without to_js.
-        if len(args) > 1:
-            args = (args[0], _EnvWrapper(args[1]), *args[2:])
-
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 class _WorkflowStepWrapper:
     __new__ = _idempotent_new
 
@@ -485,6 +244,28 @@ async def _do_call(entrypoint, name, config, callback, *results):
     return result
 
 
+def handler(func):
+    """
+    When applied to handlers such as `on_fetch` it will rewrite arguments passed in to native Python
+    types defined in this module. For example, the `request` argument to `on_fetch` gets converted
+    to an instance of the Request class defined in this module.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # TODO: support transforming kwargs
+        if len(args) > 0 and _is_js_instance(args[0], "Request"):
+            args = (Request(args[0]), *args[1:])
+
+        # Wrap `env` so that bindings can be used without to_js.
+        if len(args) > 1:
+            args = (args[0], _EnvWrapper(args[1]), *args[2:])
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
 def _wrap_class(cls):
     # Override the class __init__ so that we can wrap the `env` in the constructor.
     original_init = cls.__dict__.get("__init__")
@@ -533,6 +314,22 @@ def _wrap_workflow_step(cls):
     cls.run = wrapped_run
 
 
+def _wrap_queue_handler(cls):
+    queue_fn = getattr(cls, "queue", None)
+    if queue_fn is None:
+        return
+
+    @functools.wraps(queue_fn)
+    async def wrapped_queue(self, batch, *args, **kwargs):
+        wrapped_batch = _BindingWrapper(batch)
+        result = queue_fn(self, wrapped_batch, *args, **kwargs)
+        if inspect.iscoroutine(result):
+            result = await result
+        return result
+
+    cls.queue = wrapped_queue
+
+
 @_wrap_class
 class DurableObject:
     """
@@ -584,19 +381,3 @@ class WorkflowEntrypoint:
     def __init_subclass__(cls, **_kwargs: Any):
         _wrap_class(cls)
         _wrap_workflow_step(cls)
-
-
-def _wrap_queue_handler(cls):
-    queue_fn = getattr(cls, "queue", None)
-    if queue_fn is None:
-        return
-
-    @functools.wraps(queue_fn)
-    async def wrapped_queue(self, batch, *args, **kwargs):
-        wrapped_batch = _BindingWrapper(batch)
-        result = queue_fn(self, wrapped_batch, *args, **kwargs)
-        if inspect.iscoroutine(result):
-            result = await result
-        return result
-
-    cls.queue = wrapped_queue

workers_runtime_sdk-1.6.4/src/workers/rpc.py

@@ -0,0 +1,421 @@
+import datetime
+import inspect
+
+import js
+from js import Object
+from pyodide.ffi import JsProxy, create_proxy, to_js
+
+from .blob import Blob, File
+from .fetch import fetch
+from .formdata import FormData
+from .request import Request
+from .response import Response
+from .utils import (
+    _JS_PASSTHROUGH_TYPES,
+    _get_js_constructor_name,
+    _is_iterable,
+    _is_js_instance,
+    jsnull,
+)
+
+
+def _python_from_rpc_default_converter(value, convert, cache):
+    if value is jsnull:
+        return None
+
+    if not hasattr(value, "constructor"):
+        # Assume that the object doesn't need conversion as it's not a JS object.
+        return value
+
+    if value.constructor.name == "Response":
+        return Response(value)
+    elif value.constructor.name == "FormData":
+        return FormData(value)
+    elif value.constructor.name == "Blob":
+        return Blob(value)
+    elif value.constructor.name == "File":
+        return File(value)
+    elif value.constructor.name == "Request":
+        return Request(value)
+    elif value.constructor.name == "Date":
+        # TODO: Pyodide should gain support for this, we should upstream this.
+        return datetime.datetime.fromtimestamp(value.getTime() / 1000)
+    elif value.constructor.name == "Error":
+        return Exception(value.toString())
+    elif value.constructor.name == "Number":
+        return value.valueOf()
+
+    # We used to throw an error here, but since these conversions are now automatic when the default
+    # entrypoint is being used, it makes sense to be less loud about it and just pass through the
+    # JS value un-modified.
+    #
+    # This does mean that in the future we need to be careful when adding type wrappers for new
+    # types here, so if you're doing this make sure to do so behind a compat flag.
+    return value
+
+
+class JsDict(dict):
+    """
+    Python dictionary that allows attribute access to keys.
+
+    This is used to convert JS objects to Python dictionaries while maintaining
+    the ability to access keys as attributes.
+    """
+
+    def __getattr__(self, name):
+        # The limitation of this approach is that if there is a key that conflicts with a built-in
+        # method or attribute of the dict class, it will not be accessible through attribute access.
+        # But that is a reasonable trade-off for the convenience of being able to access keys as
+        # attributes.
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+def _replace_jsnull_with_none(obj):
+    """
+    Recursively converts JS objects to Python objects.
+    """
+    if obj is jsnull:
+        return None
+    if isinstance(obj, dict):
+        return JsDict({k: _replace_jsnull_with_none(v) for k, v in obj.items()})
+    if isinstance(obj, list):
+        return [_replace_jsnull_with_none(v) for v in obj]
+    return obj
+
+
+def python_from_rpc(obj: "JsProxy"):
+    """
+    Converts JS objects like Response, Request, Blob, etc. to equivalent Python objects defined in
+    this module and also other JS objects like Map, Set, etc. to equivalent Python stdlib objects.
+
+    This method is used for Workers RPC in Python to convert JavaScript objects to Python. As such
+    it does not support serializing all JS object types.
+    """
+
+    if obj is jsnull:
+        return None
+
+    if not hasattr(obj, "constructor"):
+        return obj
+
+    if obj.constructor.name == "TestController":
+        # This object currently has no methods defined on it. If this changes we should
+        # implement a Python wrapper for it, but for now we'll just pass in None.
+        return None
+
+    result = obj.to_py(default_converter=_python_from_rpc_default_converter)
+
+    return _replace_jsnull_with_none(result)
+
+
+def _raise_on_disabled_type(value):
+    if isinstance(value, _BindingWrapper):
+        return
+
+    if callable(value) and not isinstance(value, type):
+        return
+
+    if _is_js_instance(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):
+        # The caller is expected to await the value prior to conversion.
+        raise TypeError(f"Awaitable {type(value)} cannot be sent over RPC.")
+
+    if _is_iterable(value):
+        if isinstance(value, dict):
+            for v in value.values():
+                _raise_on_disabled_type(v)
+        else:
+            for v in value:
+                _raise_on_disabled_type(v)
+
+
+def _python_to_rpc_default_converter(obj, convert, cache):
+    if obj is None:
+        return jsnull
+
+    if isinstance(obj, _BindingWrapper):
+        return obj._binding
+
+    if hasattr(obj, "js_object"):
+        return obj.js_object
+
+    if isinstance(obj, datetime.datetime):
+        # TODO: Pyodide should gain support for this, we should upstream this.
+        return js.Date.new(obj.timestamp() * 1000)
+
+    if isinstance(obj, Exception):
+        return js.Error.new(str(obj))
+
+    if callable(obj) and not isinstance(obj, type):
+        # Wrap function with create_proxy so that
+        # it doesn't get garbage collected
+        return create_proxy(obj)
+
+    _raise_on_disabled_type(obj)
+
+    return obj
+
+
+def _replace_none_with_jsnull(value):
+    if value is None:
+        return jsnull
+    if isinstance(value, dict):
+        return {k: _replace_none_with_jsnull(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_replace_none_with_jsnull(v) for v in value]
+    return value
+
+
+def python_to_rpc(value) -> JsProxy:
+    """
+    Converts Python objects defined in this module (Response, Request, etc) and native Python types
+    like Map, Set, datetime to equivalent JavaScript types.
+
+    This method is used for Workers RPC in Python to convert Python objects to JavaScript. As such
+    it does not support serializing all Python object types.
+    """
+    if value is None:
+        return jsnull
+
+    if isinstance(value, _BindingWrapper):
+        return value._binding
+
+    value = _replace_none_with_jsnull(value)
+
+    # `to_js` won't always call the default_converter, for example when a list of tuples is passed
+    _raise_on_disabled_type(value)
+
+    result = to_js(
+        value,
+        default_converter=_python_to_rpc_default_converter,
+        dict_converter=Object.fromEntries,
+    )
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Binding wrappers
+# ---------------------------------------------------------------------------
+
+
+def _idempotent_new(cls, obj):
+    """Set __new__ on a class to this so cls is idempotent:
+
+    >>> a = A(x)
+    >>> b = A(a)
+    >>> assert a is b
+
+    For this to work, start the __init__ function with:
+
+    if obj is self:
+        return
+
+    to prevent double-init.
+    """
+    if isinstance(obj, cls):
+        return obj
+    return object.__new__(cls)
+
+
+class _BindingWrapper:
+    __new__ = _idempotent_new
+
+    def __init__(self, binding):
+        if binding is self:
+            return
+        self._binding = binding
+
+    @property
+    def _real_name(self):
+        js_name = _get_js_constructor_name(self._binding)
+        if not js_name:
+            # Should not happen, but just in case
+            return type(self).__name__
+        return js_name
+
+    def _should_wrap_nested_attribute(self, jsobj) -> bool:
+        if not isinstance(jsobj, JsProxy):
+            return False
+
+        # TODO: This allowlist approach is a workaround. The long-term fix is to
+        # add dedicated Python wrappers for these types in python_from_rpc so they
+        # never reach _BindingWrapper in the first place.
+        js_type = _get_js_constructor_name(jsobj)
+        return js_type and js_type not in _JS_PASSTHROUGH_TYPES
+
+    def _convert_result(self, result):
+        converted = python_from_rpc(result)
+
+        # After python_from_rpc, some objects may still be JsProxy objects.
+        # We need to wrap them with _BindingWrapper (or a subclass of it) again
+        # to ensure that accessing attributes on them will be properly converted.
+        if self._should_wrap_nested_attribute(converted):
+            return self.__class__(converted)
+        if isinstance(converted, list):
+            return [
+                self.__class__(item)
+                if self._should_wrap_nested_attribute(item)
+                else item
+                for item in converted
+            ]
+        return converted
+
+    @staticmethod
+    def _convert_args(args, kwargs):
+        js_args = [python_to_rpc(arg) for arg in args]
+        js_kwargs = {k: python_to_rpc(v) for k, v in kwargs.items()}
+        return js_args, js_kwargs
+
+    def _getattr_helper(self, name):
+        attr = getattr(self._binding, name)
+
+        if not callable(attr):
+            return self._convert_result(attr)
+
+        def wrapper(*args, **kwargs):
+            js_args, js_kwargs = self._convert_args(args, kwargs)
+            result = attr(*js_args, **js_kwargs)
+            if hasattr(result, "then") and callable(result.then):
+
+                async def await_and_convert():
+                    return self._convert_result(await result)
+
+                return await_and_convert()
+            return self._convert_result(result)
+
+        return wrapper
+
+    def __getattr__(self, name):
+        result = self._getattr_helper(name)
+        setattr(self, name, result)
+        return result
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self._convert_result(self._binding[key])
+        return self._convert_result(getattr(self._binding, key))
+
+    def __iter__(self):
+        binding = self._binding
+        if not hasattr(binding, "__iter__"):
+            raise TypeError(f"'{self._real_name}' object is not iterable")
+        for item in binding:
+            yield self._convert_result(item)
+
+    def __len__(self):
+        binding = self._binding
+        if not hasattr(binding, "length"):
+            raise TypeError(f"'{self._real_name}' object has no len()")
+        return binding.length
+
+
+class _FetcherWrapper(_BindingWrapper):
+    def fetch(self, *args, **kwargs):
+        return fetch(*args, fetcher=self._binding.fetch, **kwargs)
+
+
+class _DurableObjectNamespaceWrapper:
+    def __init__(self, binding):
+        self._binding = binding
+
+    def __getattr__(self, name):
+        return getattr(self._binding, name)
+
+    def get(self, *args, **kwargs):
+        return _FetcherWrapper(self._binding.get(*args, **kwargs))
+
+    def getByName(self, *args, **kwargs):
+        return _FetcherWrapper(self._binding.getByName(*args, **kwargs))
+
+    def jurisdiction(self, *args, **kwargs):
+        return _DurableObjectNamespaceWrapper(
+            self._binding.jurisdiction(*args, **kwargs)
+        )
+
+
+class _WorkflowInstanceWrapper(_BindingWrapper):
+    # status/pause/resume/restart/terminate share their JS names and are handled by
+    # the _BindingWrapper, which already converts arguments and results.
+    # Only send_event needs the snake_case -> camelCase mapping for backward compatibility
+
+    async def send_event(self, *args, **kwargs):
+        js_args, js_kwargs = self._convert_args(args, kwargs)
+        return self._convert_result(
+            await self._binding.sendEvent(*js_args, **js_kwargs)
+        )
+
+
+class _WorkflowBindingWrapper(_BindingWrapper):
+    async def get(self, *args, **kwargs):
+        js_args, js_kwargs = self._convert_args(args, kwargs)
+        return _WorkflowInstanceWrapper(await self._binding.get(*js_args, **js_kwargs))
+
+    async def create(self, *args, **kwargs):
+        js_args, js_kwargs = self._convert_args(args, kwargs)
+        return _WorkflowInstanceWrapper(
+            await self._binding.create(*js_args, **js_kwargs)
+        )
+
+    async def create_batch(self, *args, **kwargs):
+        js_args, js_kwargs = self._convert_args(args, kwargs)
+        return [
+            _WorkflowInstanceWrapper(w)
+            for w in await self._binding.createBatch(*js_args, **js_kwargs)
+        ]
+
+
+class _EnvWrapper:
+    _BINDING_TYPES = {
+        "KvNamespace",
+        "R2Bucket",
+        "D1Database",
+        "WorkerQueue",
+        "Ai",
+        "VectorizeIndexImpl",
+        "AnalyticsEngine",
+        "AnalyticsEngineDataset",
+        "LocalAnalyticsEngineDataset",
+        "ImagesBindingImpl",
+        "HostedImagesBindingImpl",
+        "Ratelimit",
+    }
+
+    __new__ = _idempotent_new
+
+    def __init__(self, env):
+        if env is self:
+            return
+        self._env = env
+
+    def _getattr_helper(self, name):
+        binding = getattr(self._env, name)
+        if _is_js_instance(binding, "Fetcher"):
+            return _FetcherWrapper(binding)
+
+        if _is_js_instance(binding, "DurableObjectNamespace"):
+            return _DurableObjectNamespaceWrapper(binding)
+
+        if _is_js_instance(binding, "WorkflowImpl"):
+            return _WorkflowBindingWrapper(binding)
+
+        if _is_js_instance(binding, self._BINDING_TYPES):
+            return _BindingWrapper(binding)
+
+        return binding
+
+    def __getattr__(self, name):
+        result = self._getattr_helper(name)
+        setattr(self, name, result)
+        return result

{workers_runtime_sdk-1.6.2 → workers_runtime_sdk-1.6.4}/uv.lock

@@ -229,7 +229,7 @@ wheels = [
 
 [[package]]
 name = "workers-runtime-sdk"
-version = "1.6.2"
+version = "1.6.4"
 source = { editable = "." }
 
 [package.dev-dependencies]

workers_runtime_sdk-1.6.2/src/workers/rpc.py

@@ -1,208 +0,0 @@
-import datetime
-import inspect
-
-import js
-from js import Object
-from pyodide.ffi import JsProxy, create_proxy, to_js
-
-from .blob import Blob, File
-from .formdata import FormData
-from .request import Request
-from .response import Response
-from .utils import _is_iterable, _is_js_instance, jsnull
-
-
-def _python_from_rpc_default_converter(value, convert, cache):
-    if value is jsnull:
-        return None
-
-    if not hasattr(value, "constructor"):
-        # Assume that the object doesn't need conversion as it's not a JS object.
-        return value
-
-    if value.constructor.name == "Response":
-        return Response(value)
-    elif value.constructor.name == "FormData":
-        return FormData(value)
-    elif value.constructor.name == "Blob":
-        return Blob(value)
-    elif value.constructor.name == "File":
-        return File(value)
-    elif value.constructor.name == "Request":
-        return Request(value)
-    elif value.constructor.name == "Date":
-        # TODO: Pyodide should gain support for this, we should upstream this.
-        return datetime.datetime.fromtimestamp(value.getTime() / 1000)
-    elif value.constructor.name == "Error":
-        return Exception(value.toString())
-    elif value.constructor.name == "Number":
-        return value.valueOf()
-
-    # We used to throw an error here, but since these conversions are now automatic when the default
-    # entrypoint is being used, it makes sense to be less loud about it and just pass through the
-    # JS value un-modified.
-    #
-    # This does mean that in the future we need to be careful when adding type wrappers for new
-    # types here, so if you're doing this make sure to do so behind a compat flag.
-    return value
-
-
-class JsDict(dict):
-    """
-    Python dictionary that allows attribute access to keys.
-
-    This is used to convert JS objects to Python dictionaries while maintaining
-    the ability to access keys as attributes.
-    """
-
-    def __getattr__(self, name):
-        # The limitation of this approach is that if there is a key that conflicts with a built-in
-        # method or attribute of the dict class, it will not be accessible through attribute access.
-        # But that is a reasonable trade-off for the convenience of being able to access keys as
-        # attributes.
-        try:
-            return self[name]
-        except KeyError:
-            raise AttributeError(name) from None
-
-    def __setattr__(self, name, value):
-        self[name] = value
-
-
-def _replace_jsnull_with_none(obj):
-    """
-    Recursively converts JS objects to Python objects.
-    """
-    if obj is jsnull:
-        return None
-    if isinstance(obj, dict):
-        return JsDict({k: _replace_jsnull_with_none(v) for k, v in obj.items()})
-    if isinstance(obj, list):
-        return [_replace_jsnull_with_none(v) for v in obj]
-    return obj
-
-
-def python_from_rpc(obj: "JsProxy"):
-    """
-    Converts JS objects like Response, Request, Blob, etc. to equivalent Python objects defined in
-    this module and also other JS objects like Map, Set, etc. to equivalent Python stdlib objects.
-
-    This method is used for Workers RPC in Python to convert JavaScript objects to Python. As such
-    it does not support serializing all JS object types.
-    """
-
-    if obj is jsnull:
-        return None
-
-    if not hasattr(obj, "constructor"):
-        return obj
-
-    if obj.constructor.name == "TestController":
-        # This object currently has no methods defined on it. If this changes we should
-        # implement a Python wrapper for it, but for now we'll just pass in None.
-        return None
-
-    result = obj.to_py(default_converter=_python_from_rpc_default_converter)
-
-    return _replace_jsnull_with_none(result)
-
-
-def _raise_on_disabled_type(value):
-    # Lazy import: _BindingWrapper is defined in _workers.py
-    from ._workers import _BindingWrapper
-
-    if isinstance(value, _BindingWrapper):
-        return
-
-    if callable(value) and not isinstance(value, type):
-        return
-
-    if _is_js_instance(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):
-        # The caller is expected to await the value prior to conversion.
-        raise TypeError(f"Awaitable {type(value)} cannot be sent over RPC.")
-
-    if _is_iterable(value):
-        if isinstance(value, dict):
-            for v in value.values():
-                _raise_on_disabled_type(v)
-        else:
-            for v in value:
-                _raise_on_disabled_type(v)
-
-
-def _python_to_rpc_default_converter(obj, convert, cache):
-    # Lazy import: _BindingWrapper is defined in _workers.py
-    from ._workers import _BindingWrapper
-
-    if obj is None:
-        return jsnull
-
-    if isinstance(obj, _BindingWrapper):
-        return obj._binding
-
-    if hasattr(obj, "js_object"):
-        return obj.js_object
-
-    if isinstance(obj, datetime.datetime):
-        # TODO: Pyodide should gain support for this, we should upstream this.
-        return js.Date.new(obj.timestamp() * 1000)
-
-    if isinstance(obj, Exception):
-        return js.Error.new(str(obj))
-
-    if callable(obj) and not isinstance(obj, type):
-        # Wrap function with create_proxy so that
-        # it doesn't get garbage collected
-        return create_proxy(obj)
-
-    _raise_on_disabled_type(obj)
-
-    return obj
-
-
-def _replace_none_with_jsnull(value):
-    if value is None:
-        return jsnull
-    if isinstance(value, dict):
-        return {k: _replace_none_with_jsnull(v) for k, v in value.items()}
-    if isinstance(value, list):
-        return [_replace_none_with_jsnull(v) for v in value]
-    return value
-
-
-def python_to_rpc(value) -> JsProxy:
-    """
-    Converts Python objects defined in this module (Response, Request, etc) and native Python types
-    like Map, Set, datetime to equivalent JavaScript types.
-
-    This method is used for Workers RPC in Python to convert Python objects to JavaScript. As such
-    it does not support serializing all Python object types.
-    """
-    # Lazy import: _BindingWrapper is defined in _workers.py
-    # TODO: refactor more to avoid circular imports
-    from ._workers import _BindingWrapper
-
-    if value is None:
-        return jsnull
-
-    if isinstance(value, _BindingWrapper):
-        return value._binding
-
-    value = _replace_none_with_jsnull(value)
-
-    # `to_js` won't always call the default_converter, for example when a list of tuples is passed
-    _raise_on_disabled_type(value)
-
-    result = to_js(
-        value,
-        default_converter=_python_to_rpc_default_converter,
-        dict_converter=Object.fromEntries,
-    )
-
-    return result