Simplify Promise handling

Author: bpcreech

src/py_mini_racer/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from py_mini_racer._context import PyJsFunctionType
 from py_mini_racer._dll import (
     DEFAULT_V8_FLAGS,
     LibAlreadyInitializedError,
@@ -23,6 +22,7 @@
     JSSymbol,
     JSUndefined,
     JSUndefinedType,
+    PyJsFunctionType,
     PythonJSConvertedTypes,
 )
 from py_mini_racer._value_handle import (

src/py_mini_racer/_context.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
-from asyncio import Task, create_task, get_running_loop
-from collections.abc import AsyncGenerator, Awaitable, Callable, Generator, Iterator
 from concurrent.futures import Future as SyncFuture
 from concurrent.futures import TimeoutError as SyncTimeoutError
-from contextlib import asynccontextmanager, contextmanager, suppress
-from dataclasses import dataclass, field
+from contextlib import contextmanager, suppress
 from itertools import count
-from traceback import format_exc
 from typing import TYPE_CHECKING, Any, cast
 
 from py_mini_racer._abstract_context import AbstractContext
@@ -26,12 +22,11 @@
 
 if TYPE_CHECKING:
     import ctypes
+    from collections.abc import Callable, Generator, Iterator
 
     from py_mini_racer._abstract_context import AbstractValueHandle
     from py_mini_racer._value_handle import RawValueHandleType
 
-PyJsFunctionType = Callable[..., Awaitable[PythonJSConvertedTypes]]
-
 
 def context_count() -> int:
     """For tests only: how many context handles are still allocated?"""
@@ -351,86 +346,3 @@ def close(self) -> None:
 
     def __del__(self) -> None:
         self.close()
-
-
-@asynccontextmanager
-async def wrap_py_function_as_js_function(
-    context: Context, func: PyJsFunctionType
-) -> AsyncGenerator[JSFunction, None]:
-    js_to_py_callback_processor = _JsToPyCallbackProcessor(func, context)
-
-    loop = get_running_loop()
-
-    def on_called_from_js(value: PythonJSConvertedTypes | JSEvalException) -> None:
-        loop.call_soon_threadsafe(
-            js_to_py_callback_processor.process_one_invocation_from_js, value
-        )
-
-    with context.js_to_py_callback(on_called_from_js) as js_to_py_callback:
-        # Every time our callback is called from JS, on the JS side we
-        # instantiate a JS Promise and immediately pass its resolution functions
-        # into our Python callback function. While we wait on Python's asyncio
-        # loop to process this call, we can return the Promise to the JS caller,
-        # thus exposing what looks like an ordinary async function on the JS
-        # side of things.
-        wrap_outbound_calls_with_js_promises = cast(
-            "JSFunction",
-            context.evaluate(
-                """
-fn => {
-    return (...arguments) => {
-        let p = Promise.withResolvers();
-
-        fn(arguments, p.resolve, p.reject);
-
-        return p.promise;
-    }
-}
-"""
-            ),
-        )
-
-        yield cast(
-            "JSFunction", wrap_outbound_calls_with_js_promises(js_to_py_callback)
-        )
-
-
-@dataclass(frozen=True)
-class _JsToPyCallbackProcessor:
-    """Processes incoming calls from JS into Python.
-
-    Note that this is not thread-safe and is thus suitable for use with only one asyncio
-    loop."""
-
-    _py_func: PyJsFunctionType
-    _context: Context
-    _ongoing_callbacks: set[Task[PythonJSConvertedTypes | JSEvalException]] = field(
-        default_factory=set
-    )
-
-    def process_one_invocation_from_js(
-        self, params: PythonJSConvertedTypes | JSEvalException
-    ) -> None:
-        arguments, resolve, reject = cast("JSArray", params)
-        arguments = cast("JSArray", arguments)
-        resolve = cast("JSFunction", resolve)
-        reject = cast("JSFunction", reject)
-
-        async def await_into_js_promise_resolvers() -> None:
-            try:
-                result = await self._py_func(*arguments)
-                resolve(result)
-            except Exception:  # noqa: BLE001
-                # Convert this Python exception into a JS exception so we can send
-                # it into JS:
-                err_maker = cast(
-                    "JSFunction", self._context.evaluate("s => new Error(s)")
-                )
-                reject(err_maker(f"Error running Python function:\n{format_exc()}"))
-
-        # Start a new task to await this invocation:
-        task = create_task(await_into_js_promise_resolvers())
-
-        self._ongoing_callbacks.add(task)
-
-        task.add_done_callback(self._ongoing_callbacks.discard)

src/py_mini_racer/_exc.py

@@ -14,7 +14,7 @@ class JSEvalException(MiniRacerBaseException):
     """JavaScript could not be executed."""
 
 
-class JSTimeoutException(JSEvalException):
+class JSTimeoutException(JSEvalException, TimeoutError):  # noqa: N818
     """JavaScript execution timed out."""
 
     def __init__(self) -> None:

src/py_mini_racer/_mini_racer.py

@@ -4,19 +4,23 @@
 from json import JSONEncoder
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from py_mini_racer._context import Context, wrap_py_function_as_js_function
+from py_mini_racer._context import Context
 from py_mini_racer._dll import init_mini_racer
 from py_mini_racer._exc import MiniRacerBaseException
 from py_mini_racer._set_timeout import INSTALL_SET_TIMEOUT
+from py_mini_racer._wrap_py_function import wrap_py_function_as_js_function
 
 if TYPE_CHECKING:
     from contextlib import AbstractAsyncContextManager
     from types import TracebackType
 
     from typing_extensions import Self
 
-    from py_mini_racer._context import PyJsFunctionType
-    from py_mini_racer._types import JSFunction, PythonJSConvertedTypes
+    from py_mini_racer._types import (
+        JSFunction,
+        PyJsFunctionType,
+        PythonJSConvertedTypes,
+    )
 
 
 class WrongReturnTypeException(MiniRacerBaseException):

src/py_mini_racer/_objects.py

@@ -4,7 +4,6 @@
 
 from asyncio import get_running_loop
 from concurrent.futures import Future as SyncFuture
-from contextlib import contextmanager
 from operator import index as op_index
 from typing import TYPE_CHECKING, Any, cast
 
@@ -20,10 +19,11 @@
     JSUndefinedType,
     PythonJSConvertedTypes,
 )
+from py_mini_racer._wrap_py_function import wrap_py_function_as_js_function
 
 if TYPE_CHECKING:
     from asyncio import Future
-    from collections.abc import Callable, Generator, Iterator
+    from collections.abc import Generator, Iterator
 
     from py_mini_racer._abstract_context import AbstractContext, AbstractValueHandle
     from py_mini_racer._exc import JSEvalException
@@ -171,56 +171,55 @@ def get(self, *, timeout: float | None = None) -> PythonJSConvertedTypes:
                 This is deprecated; use timeout_sec instead.
         """
 
-        future: SyncFuture[PythonJSConvertedTypes] = SyncFuture()
+        future: SyncFuture[JSArray] = SyncFuture()
+        is_rejected = False
 
-        def future_caller(value: PythonJSConvertedTypes) -> None:
-            future.set_result(value)
+        def on_resolved(value: PythonJSConvertedTypes | JSEvalException) -> None:
+            future.set_result(cast("JSArray", value))
 
-        with self._attach_callbacks_to_promise(future_caller):
-            return self._unpack_promise_results(future.result(timeout=timeout))
+        def on_rejected(value: PythonJSConvertedTypes | JSEvalException) -> None:
+            nonlocal is_rejected
+            is_rejected = True
+            future.set_result(cast("JSArray", value))
 
-    def __await__(self) -> Generator[Any, None, Any]:
-        return self._do_await().__await__()
-
-    async def _do_await(self) -> PythonJSConvertedTypes:
-        loop = get_running_loop()
-        future: Future[PythonJSConvertedTypes] = loop.create_future()
-
-        def future_caller(value: PythonJSConvertedTypes) -> None:
-            loop.call_soon_threadsafe(future.set_result, value)
+        with (
+            self._ctx.js_to_py_callback(on_resolved) as on_resolved_js_func,
+            self._ctx.js_to_py_callback(on_rejected) as on_rejected_js_func,
+        ):
+            self._ctx.promise_then(self, on_resolved_js_func, on_rejected_js_func)
 
-        with self._attach_callbacks_to_promise(future_caller):
-            return self._unpack_promise_results(await future)
+            result = future.result(timeout=timeout)
 
-    @contextmanager
-    def _attach_callbacks_to_promise(
-        self, future_caller: Callable[[Any], None]
-    ) -> Generator[None, None, None]:
-        """Attach the given Python callbacks to a JS Promise."""
+        if is_rejected:
+            msg = _get_exception_msg(result[0])
+            raise JSPromiseError(msg)
 
-        def on_resolved_and_cleanup(
-            value: PythonJSConvertedTypes | JSEvalException,
-        ) -> None:
-            future_caller([False, cast("JSArray", value)])
+        return result[0]
 
-        def on_rejected_and_cleanup(
-            value: PythonJSConvertedTypes | JSEvalException,
-        ) -> None:
-            future_caller([True, cast("JSArray", value)])
+    def __await__(self) -> Generator[Any, None, Any]:
+        return self._do_await().__await__()
 
-        with (
-            self._ctx.js_to_py_callback(on_resolved_and_cleanup) as on_resolved_js_func,
-            self._ctx.js_to_py_callback(on_rejected_and_cleanup) as on_rejected_js_func,
+    async def _do_await(self) -> PythonJSConvertedTypes:
+        future: Future[PythonJSConvertedTypes] = get_running_loop().create_future()
+
+        async def on_resolved(value: PythonJSConvertedTypes | JSEvalException) -> None:
+            future.set_result(cast("PythonJSConvertedTypes", value))
+
+        async def on_rejected(value: PythonJSConvertedTypes | JSEvalException) -> None:
+            future.set_exception(
+                JSPromiseError(
+                    _get_exception_msg(cast("PythonJSConvertedTypes", value))
+                )
+            )
+
+        async with (
+            wrap_py_function_as_js_function(
+                self._ctx, on_resolved
+            ) as on_resolved_js_func,
+            wrap_py_function_as_js_function(
+                self._ctx, on_rejected
+            ) as on_rejected_js_func,
         ):
             self._ctx.promise_then(self, on_resolved_js_func, on_rejected_js_func)
-            yield
 
-    def _unpack_promise_results(
-        self, results: PythonJSConvertedTypes
-    ) -> PythonJSConvertedTypes:
-        is_rejected, argv = cast("JSArray", results)
-        result = cast("JSArray", argv)[0]
-        if is_rejected:
-            msg = _get_exception_msg(result)
-            raise JSPromiseError(msg)
-        return result
+            return await future

src/py_mini_racer/_types.py

@@ -3,7 +3,13 @@
 from __future__ import annotations
 
 from abc import ABC
-from collections.abc import Generator, MutableMapping, MutableSequence
+from collections.abc import (
+    Awaitable,
+    Callable,
+    Generator,
+    MutableMapping,
+    MutableSequence,
+)
 from datetime import datetime
 from typing import Any, TypeAlias
 
@@ -100,3 +106,5 @@ async def _do_await(self) -> PythonJSConvertedTypes:
     | JSArray
     | None
 )
+
+PyJsFunctionType = Callable[..., Awaitable[PythonJSConvertedTypes]]