Merge pull request #727 from kkollsga/fix/optional-js-runtime-707

fix: replace quickjs with mini-racer for Python 3.13 + Windows support

Author: ObservedObserver

pygwalker/utils/dsl_transform.py

@@ -1,28 +1,62 @@
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional, Callable
 import os
 import json
 
-try:
-    from quickjs import Function
-except ImportError as exc:
-    raise ImportError("`quickjs` is not installed, please install it first. refer it: `pip install quickjs`.") from exc
-
 from pygwalker._constants import ROOT_DIR
 from .randoms import rand_str
 
+_dsl_to_workflow_js = None  # type: Optional[Callable]
+_vega_to_dsl_js = None  # type: Optional[Callable]
+
+_INSTALL_MSG = (
+    "Static HTML chart export requires a JavaScript runtime.\n"
+    "Install with: pip install pygwalker[export]\n"
+    "Or manually: pip install mini-racer"
+)
+
+
+def _make_js_callable(func_name, js_code):
+    """Create a callable that executes a named JS function via mini-racer (V8)."""
+    from py_mini_racer import MiniRacer
+
+    ctx = MiniRacer()
+    ctx.eval(js_code)
+
+    def call(*args):
+        if not args:
+            return ctx.eval("{}()".format(func_name))
+        args_json = json.dumps(args)
+        return ctx.eval("{}(...{})".format(func_name, args_json))
+
+    return call
+
+
+def _ensure_js_runtime():
+    """Lazily initialize JS runtime on first actual use."""
+    global _dsl_to_workflow_js, _vega_to_dsl_js
+    if _dsl_to_workflow_js is not None:
+        return
+
+    try:
+        dsl_js_path = os.path.join(ROOT_DIR, 'templates', 'dist', 'dsl-to-workflow.umd.js')
+        vega_js_path = os.path.join(ROOT_DIR, 'templates', 'dist', 'vega-to-dsl.umd.js')
 
-with open(os.path.join(ROOT_DIR, 'templates', 'dist', 'dsl-to-workflow.umd.js'), 'r', encoding='utf8') as f:
-    _dsl_to_workflow_js = Function('main', f.read())
+        with open(dsl_js_path, 'r', encoding='utf8') as f:
+            _dsl_to_workflow_js = _make_js_callable('main', f.read())
 
-with open(os.path.join(ROOT_DIR, 'templates', 'dist', 'vega-to-dsl.umd.js'), 'r', encoding='utf8') as f:
-    _vega_to_dsl_js = Function('main', f.read())
+        with open(vega_js_path, 'r', encoding='utf8') as f:
+            _vega_to_dsl_js = _make_js_callable('main', f.read())
+    except ImportError:
+        raise ImportError(_INSTALL_MSG)
 
 
 def dsl_to_workflow(dsl: Dict[str, Any]) -> Dict[str, Any]:
+    _ensure_js_runtime()
     return json.loads(_dsl_to_workflow_js(json.dumps(dsl)))
 
 
 def vega_to_dsl(vega_config: Dict[str, Any], fields: List[Dict[str, Any]]) -> Dict[str, Any]:
+    _ensure_js_runtime()
     return json.loads(_vega_to_dsl_js(json.dumps({
         "vl": vega_config,
         "allFields": fields,

pyproject.toml

@@ -35,7 +35,6 @@ dependencies = [
     "packaging",
     "numpy",
     "ipylab<=1.0.0",
-    "quickjs",
     "traitlets",
     "anywidget",
 ]
@@ -65,8 +64,9 @@ labv4 = [
     "jupyter-server>2.5.0",
     "ipywidgets>=8.0.0"
 ]
+export = ["mini-racer>=0.12"]
 all = [
-    "pygwalker[pandas,polars,streamlit,reflex]",
+    "pygwalker[pandas,polars,streamlit,reflex,export]",
 ]
 dev = [
     "build",

tests/test_dsl_transform.py

@@ -0,0 +1,80 @@
+from unittest import mock
+import builtins
+
+import pytest
+
+import pygwalker.utils.dsl_transform as mod
+from pygwalker.utils.dsl_transform import dsl_to_workflow, vega_to_dsl
+
+
+def _reset_runtime():
+    """Reset the lazy-initialized JS runtime so tests are independent."""
+    mod._dsl_to_workflow_js = None
+    mod._vega_to_dsl_js = None
+
+
+def test_dsl_to_workflow_returns_valid_workflow():
+    _reset_runtime()
+    result = dsl_to_workflow({})
+    assert "workflow" in result
+    assert isinstance(result["workflow"], list)
+
+
+def test_dsl_to_workflow_with_fields():
+    _reset_runtime()
+    spec = {
+        "encodings": {
+            "dimensions": [{"fid": "a", "name": "a", "semanticType": "nominal", "analyticType": "dimension"}],
+            "measures": [{"fid": "b", "name": "b", "semanticType": "quantitative", "analyticType": "measure"}],
+        }
+    }
+    result = dsl_to_workflow(spec)
+    assert "workflow" in result
+
+
+def test_vega_to_dsl_returns_expected_keys():
+    _reset_runtime()
+    vega_spec = {
+        "mark": "bar",
+        "encoding": {
+            "x": {"field": "a", "type": "nominal"},
+            "y": {"field": "b", "type": "quantitative"},
+        },
+    }
+    fields = [
+        {"fid": "a", "name": "a", "analyticType": "dimension", "semanticType": "nominal"},
+        {"fid": "b", "name": "b", "analyticType": "measure", "semanticType": "quantitative"},
+    ]
+    result = vega_to_dsl(vega_spec, fields)
+    assert "config" in result
+    assert "encodings" in result
+
+
+def test_import_error_when_no_js_runtime():
+    _reset_runtime()
+    original_import = builtins.__import__
+
+    def block_mini_racer(name, *args, **kwargs):
+        if name == "py_mini_racer":
+            raise ImportError("mocked")
+        return original_import(name, *args, **kwargs)
+
+    with mock.patch("builtins.__import__", side_effect=block_mini_racer):
+        with pytest.raises(ImportError, match="pip install pygwalker\\[export\\]"):
+            dsl_to_workflow({})
+
+
+def test_runtime_initialized_only_once():
+    _reset_runtime()
+    original = mod._make_js_callable
+    call_count = [0]
+
+    def counting_make(*args, **kwargs):
+        call_count[0] += 1
+        return original(*args, **kwargs)
+
+    with mock.patch.object(mod, '_make_js_callable', side_effect=counting_make):
+        dsl_to_workflow({})
+        dsl_to_workflow({})
+    # _make_js_callable is called twice during init (once per UMD file), but only on first call
+    assert call_count[0] == 2