workers-runtime-sdk 1.4.0__tar.gz → 1.4.2__tar.gz

{workers_runtime_sdk-1.4.0 → workers_runtime_sdk-1.4.2}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 <!-- version list -->
 
+## v1.4.2 (2026-06-18)
+
+### Bug Fixes
+
+- Make iterables work correctly when returned from rpc call
+  ([#127](https://github.com/cloudflare/workers-py/pull/127),
+  [`36dc659`](https://github.com/cloudflare/workers-py/commit/36dc659d6ba394d75e3d11b3e78e2b08fcd91c9f))
+
+
+## v1.4.1 (2026-06-18)
+
+### Bug Fixes
+
+- Fix ReadableStream being incorrectly wrapped by BindingWrapper
+  ([#128](https://github.com/cloudflare/workers-py/pull/128),
+  [`85ad1f3`](https://github.com/cloudflare/workers-py/commit/85ad1f33d5f23fd932c0eac5cc5a9f7d39159423))
+
+
 ## v1.4.0 (2026-06-17)
 
 ### Features

{workers_runtime_sdk-1.4.0 → workers_runtime_sdk-1.4.2}/PKG-INFO

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

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

{workers_runtime_sdk-1.4.0 → workers_runtime_sdk-1.4.2}/src/workers/_workers.py

@@ -392,6 +392,19 @@ RESPONSE_ACCEPTED_TYPES = {
     "Response",
 }
 
+# JS built-in types that should NOT be wrapped in _BindingWrapper.
+# These have their own Python-side semantics (e.g. passed directly to Response())
+# and wrapping them breaks property access like `.constructor.name`.
+_JS_PASSTHROUGH_TYPES = RESPONSE_ACCEPTED_TYPES | {
+    "Headers",
+}
+
+
+def _get_js_constructor_name(obj) -> str | None:
+    if hasattr(obj, "constructor"):
+        return obj.constructor.name
+    return None
+
 
 class Response(FetchResponse):
     """
@@ -414,11 +427,10 @@ class Response(FetchResponse):
         https://developer.mozilla.org/en-US/docs/Web/API/Response/Response.
         """
         # Verify passed in types.
-        if hasattr(body, "constructor"):
-            if body.constructor.name not in RESPONSE_ACCEPTED_TYPES:
-                raise TypeError(
-                    f"Unsupported type in Response: {body.constructor.name}"
-                )
+        js_type = _get_js_constructor_name(body)
+        if js_type:
+            if js_type not in RESPONSE_ACCEPTED_TYPES:
+                raise TypeError(f"Unsupported type in Response: {js_type}")
         elif not isinstance(body, str | FormData | bytes) and body is not None:
             raise TypeError(f"Unsupported type in Response: {type(body).__name__}")
 
@@ -1110,20 +1122,37 @@ class _BindingWrapper:
     def __init__(self, binding):
         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.
-        # For now, we wrap all of them with the _BindingWrapper (or a subclass of it)
-        # so that accessing attributes on them will be properly converted.
-
-        # TODO: This is a bit of a hack. We should revisit when there are more
-        # bindings to support with different return types.
-        if isinstance(converted, JsProxy):
+        # 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 isinstance(item, JsProxy) else item
+                self.__class__(item)
+                if self._should_wrap_nested_attribute(item)
+                else item
                 for item in converted
             ]
         return converted
@@ -1154,8 +1183,23 @@ class _BindingWrapper:
         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):