support for async; get runtime from context

Author: jrialland

c-sources/binding.c

@@ -42,9 +42,10 @@ typedef struct
 static PyTypeObject ContextType;
 static PyObject *Context_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
 static void Context_dealloc(Context *self);
-static PyObject *Context_Eval(Context *self, PyObject *args);
+static PyObject *Context_Eval(Context *self, PyObject *args, PyObject *kwargs);
+static PyObject *Context_EvalSync(Context *self, PyObject *args, PyObject *kwargs);
 static PyObject *Context_Set(Context *self, PyObject *args);
-
+static PyObject * Context_GetRuntime(Context *self, PyObject *Py_UNUSED(ignored));
 static JSValue py_to_js_value(JSContext *ctx, PyObject *obj);
 static JSValue py_callable_handler(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic, JSValue *func_data);
 
@@ -255,7 +256,12 @@ static PyObject *js_value_to_py(JSContext *ctx, JSValue val)
     case JS_TAG_EXCEPTION:
     {
         JSValue exc = JS_GetException(ctx);
-        const char *str = JS_ToCString(ctx, exc);
+        JSValue val = JS_GetPropertyStr(ctx, exc, "stack");
+        if (JS_IsUndefined(val))
+        {
+            val = JS_DupValue(ctx, exc);
+        }
+        const char *str = JS_ToCString(ctx, val);
         if (str)
         {
             PyErr_SetString(PyExc_RuntimeError, str);
@@ -265,6 +271,7 @@ static PyObject *js_value_to_py(JSContext *ctx, JSValue val)
         {
             PyErr_SetString(PyExc_RuntimeError, "Unknown QuickJS exception");
         }
+        JS_FreeValue(ctx, val);
         JS_FreeValue(ctx, exc);
         return NULL;
     }
@@ -411,21 +418,59 @@ static PyObject *Context_Set(Context *self, PyObject *args)
     Py_RETURN_NONE;
 }
 
-static PyObject *Context_Eval(Context *self, PyObject *args)
+static PyObject *Context_Eval(Context *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"code", "filename", NULL};
+    const char *code;
+    const char *filename = "input.js";
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|s", kwlist, &code, &filename))
+    {
+        return NULL;
+    }
+
+    JSValue val = JS_Eval(self->ctx, code, strlen(code), filename, JS_EVAL_TYPE_GLOBAL);
+    PyObject *result = js_value_to_py(self->ctx, val);
+    JS_FreeValue(self->ctx, val);
+    return result;
+}
+
+static PyObject *Context_EvalSync(Context *self, PyObject *args, PyObject *kwargs)
 {
+    static char *kwlist[] = {"code", "filename", NULL};
     const char *code;
     const char *filename = "input.js";
-    if (!PyArg_ParseTuple(args, "s|s", &code, &filename))
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|s", kwlist, &code, &filename))
     {
         return NULL;
     }
 
     JSValue val = JS_Eval(self->ctx, code, strlen(code), filename, JS_EVAL_TYPE_GLOBAL);
+
+    // Run the job queue until empty
+    JSContext *ctx1;
+    int err;
+    while (JS_IsJobPending(self->runtime->rt))
+    {
+        err = JS_ExecutePendingJob(self->runtime->rt, &ctx1);
+        if (err < 0)
+        {
+            JS_FreeValue(self->ctx, val);
+            // js_value_to_py with JS_EXCEPTION will set the Python error
+            return js_value_to_py(self->ctx, JS_EXCEPTION);
+        }
+    }
+
     PyObject *result = js_value_to_py(self->ctx, val);
     JS_FreeValue(self->ctx, val);
     return result;
 }
 
+static PyObject * Context_GetRuntime(Context *self, PyObject *Py_UNUSED(ignored))
+{
+    Py_INCREF(self->runtime);
+    return (PyObject *)self->runtime;
+}
+
 static PyObject *Context_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyErr_SetString(PyExc_RuntimeError, "Cannot create Context directly; use Runtime.new_context()");
@@ -441,8 +486,10 @@ static void Context_dealloc(Context *self)
 }
 
 static PyMethodDef Context_methods[] = {
-    {"eval", (PyCFunction)Context_Eval, METH_VARARGS, "Evaluate JavaScript code"},
+    {"eval", (PyCFunction)Context_Eval, METH_VARARGS | METH_KEYWORDS, "Evaluate JavaScript code"},
+    {"eval_sync", (PyCFunction)Context_EvalSync, METH_VARARGS | METH_KEYWORDS, "Evaluate JavaScript code and run pending jobs"},
     {"set", (PyCFunction)Context_Set, METH_VARARGS, "Set a global value"},
+    {"get_runtime", (PyCFunction)Context_GetRuntime, METH_NOARGS, "Get the Runtime associated with this Context"},
     {NULL} /* Sentinel */
 };
 

src/quickjs_runtime/__init__.py

@@ -43,15 +43,24 @@ def run_gc(self) -> None:
     def new_context(self) -> "IContext":
         ...
 
-class IContext(ABC):
+class Context(ABC):
+
     @abstractmethod
     def eval(self, code: str, filename: str = "input.js") -> any:
         ...
 
+    @abstractmethod
+    def eval_sync(self, code: str, filename: str = "input.js") -> any:
+        ...
+
     @abstractmethod
     def set(self, name: str, value: any) -> None:
         ...
 
+    @abstractmethod
+    def get_runtime(self) -> IRuntime:
+        ...
+
 
 class Runtime(IRuntime, _Runtime):
 
@@ -83,8 +92,9 @@ def run_gc(self) -> None:
         return _Runtime.run_gc(self)
 
     @override
-    def new_context(self) -> "IContext":
-        return _Runtime.new_context(self)
+    def new_context(self) -> Context:
+        ctx = _Runtime.new_context(self)
+        return ctx
 
 
-__all__ = ["Runtime"]
+__all__ = ["Runtime", "Context"]

tests/test_runtime.py

@@ -144,3 +144,63 @@ def test_nested_collections():
 
     res = ctx.eval("({a: [1, 2], b: {c: 3}})")
     assert res == {"a": [1, 2], "b": {"c": 3}}
+
+
+def test_eval_sync():
+    rt = Runtime()
+    ctx = rt.new_context()
+
+    # Test resolving a promise
+    script = """
+    var out = 0;
+    async function test() {
+        out = await Promise.resolve(100);
+    }
+    test();
+    out;
+    """
+    # eval() will return 0 because it doesn't wait for the promise
+    assert ctx.eval(script) == 0
+
+    # eval_sync() will wait for the job queue to be empty
+    script = """
+    var out_async = 0;
+    async function test_async() {
+        out_async = await Promise.resolve(200);
+    }
+    test_async();
+    out_async;
+    """
+    # Note: the return value of the script is still eval'd before the loop, 
+    # but we want to check if the side effect (out_async = 200) happened.
+    ctx.eval_sync(script)
+    assert ctx.eval("out_async") == 200
+
+
+def test_eval_filename():
+    rt = Runtime()
+    ctx = rt.new_context()
+
+    # Verify positional filename
+    try:
+        ctx.eval("syntax error", "custom_pos.js")
+    except RuntimeError as e:
+        assert "custom_pos.js" in str(e)
+
+    # Verify keyword filename
+    try:
+        ctx.eval(code="syntax error", filename="custom_kw.js")
+    except RuntimeError as e:
+        assert "custom_kw.js" in str(e)
+
+    # Verify eval_sync keyword filename
+    try:
+        ctx.eval_sync(code="syntax error", filename="custom_sync_kw.js")
+    except RuntimeError as e:
+        assert "custom_sync_kw.js" in str(e)
+
+def test_runtime_from_context():
+    rt = Runtime()
+    ctx = rt.new_context()
+    rt_from_ctx = ctx.get_runtime()
+    assert rt_from_ctx is rt