Add Pyodide implementation

jest.config.js

@@ -46,6 +46,7 @@ module.exports = {
         },
       },
     ],
+    "\\.py$": "<rootDir>/src/tests/raw-text-transformer.js",
   },
   transformIgnorePatterns: [
     "/node_modules/(?!(@sourceacademy/wasm-util|@sourceacademy/conductor)/).+\\.js$",

package.json

@@ -12,8 +12,8 @@
     "jsdoc": "./scripts/jsdoc.sh prepare",
     "jsdoc:run": "./scripts/jsdoc.sh run",
     "jsdoc:clean": "./scripts/jsdoc.sh clean",
-    "test": "jest",
-    "test-coverage": "jest --coverage",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test-coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
     "lint": "eslint --concurrency=auto src",
     "format": "prettier --write \"**/*.{ts,tsx,json,js,mjs}\"",
     "format:ci": "prettier --list-different \"**/*.{ts,tsx,json,js,mjs}\"",
@@ -60,11 +60,13 @@
   },
   "dependencies": {
     "@sourceacademy/conductor": "^0.3.0",
+    "@sourceacademy/torch": "^0.1.0",
     "@sourceacademy/wasm-util": "^1.0.6",
     "fast-levenshtein": "^3.0.0",
     "mathjs": "^14.9.1",
     "moo": "^0.5.2",
     "nearley": "^2.20.1",
+    "pyodide": "^0.29.3",
     "wabt": "^1.0.37"
   }
 }

rollup.config.mjs

@@ -6,15 +6,30 @@ import commonjs from "@rollup/plugin-commonjs";
 import nodePolyfills from "rollup-plugin-polyfill-node";
 import replace from "@rollup/plugin-replace";
 import wasm from "@rollup/plugin-wasm";
+import { readFileSync } from "fs";
 
 // Env EVALUATOR is set by scripts/build.ts.
 const EVALUATOR = process.env.EVALUATOR;
 if (!EVALUATOR) {
   throw new Error("EVALUATOR env var must be set. Use scripts/build.ts.");
 }
 
+/** Plugin: import .py files as strings. */
+function rawPy() {
+  return {
+    name: "raw-py",
+    load(id) {
+      if (id.endsWith(".py")) {
+        const text = readFileSync(id, "utf-8");
+        return `export default ${JSON.stringify(text)};`;
+      }
+    },
+  };
+}
+
 function plugins() {
   return [
+    rawPy(),
     replace({
       preventAssignment: true,
       values: { __EVALUATOR__: EVALUATOR },
@@ -45,6 +60,7 @@ const config = [
       format: "iife",
       name: "PySlangWorker",
       sourcemap: true,
+      inlineDynamicImports: true,
     },
     plugins: plugins(),
   },
@@ -58,6 +74,7 @@ const config = [
       format: "cjs",
       exports: "default",
       sourcemap: true,
+      inlineDynamicImports: true,
     },
     plugins: plugins(),
   },

scripts/build.ts

@@ -12,6 +12,11 @@ const allTargets = [
   "PyWasmEvaluator",
   "PySvmlEvaluator",
   "PySvmlSinterEvaluator",
+  "PyodideEvaluator1",
+  "PyodideEvaluator2",
+  "PyodideEvaluator3",
+  "PyodideEvaluator4",
+  "PyodideEvaluatorFull",
 ] as const;
 
 type EvaluatorName = (typeof allTargets)[number];

src/conductor/index.ts

@@ -1,9 +1,16 @@
+export {
+  PyodideEvaluator1,
+  PyodideEvaluator2,
+  PyodideEvaluator3,
+  PyodideEvaluator4,
+  PyodideEvaluatorFull,
+} from "../pyodide/PyodideEvaluator";
 export {
   PyCseEvaluator1,
   PyCseEvaluator2,
   PyCseEvaluator3,
   PyCseEvaluator4,
 } from "./PyCseEvaluator";
 export { PySvmlEvaluator } from "./PySvmlEvaluator";
-export { PyWasmEvaluator } from "./PyWasmEvaluator";
 export { PySvmlSinterEvaluator } from "./PySvmlSinterEvaluator";
+export { PyWasmEvaluator } from "./PyWasmEvaluator";

src/pyodide/PyodideEvaluator.ts

@@ -0,0 +1,120 @@
+import { ConductorError } from "@sourceacademy/conductor/common";
+import { BasicEvaluator, IRunnerPlugin } from "@sourceacademy/conductor/runner";
+import type { PyodideInterface } from "pyodide";
+import { parse } from "../parser/parser-adapter";
+import { analyze } from "../resolver/analysis";
+import { getNonTorchImportRoots, rewriteTorchImports } from "./importAnalyzer";
+import { loadPyodideGeneric } from "./loadPyodide";
+import { loadTorch } from "./loadTorch";
+
+export default abstract class PyodideEvaluator extends BasicEvaluator {
+  protected pyodide: Promise<PyodideInterface>;
+  private torchLoaded = false;
+
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor);
+    this.pyodide = loadPyodideGeneric().then(async pyodide => {
+      await pyodide.loadPackage("micropip");
+      await pyodide.setStdout({
+        batched: (output: string) => {
+          this.conductor.sendOutput(output);
+        },
+      });
+      return pyodide;
+    });
+  }
+
+  protected abstract validateChunk(_chunk: string): void;
+
+  async evaluateChunk(chunk: string): Promise<void> {
+    this.validateChunk(chunk);
+
+    const pyodide = await this.pyodide;
+
+    // --- Use Python's ast module (via Pyodide) to detect and rewrite torch imports ---
+    const { code, hasTorch } = await rewriteTorchImports(pyodide, chunk);
+
+    if (hasTorch && !this.torchLoaded) {
+      await loadTorch(pyodide);
+      pyodide.globals.set("__sa_import_torch", pyodide.globals.get("torch"));
+      this.torchLoaded = true;
+    }
+
+    // --- Install any other imported modules via micropip ---
+    const otherRoots = await getNonTorchImportRoots(pyodide, chunk);
+    if (otherRoots.size > 0) {
+      const modulesArray = Array.from(otherRoots);
+      const installerCode = `
+import importlib, micropip
+mods = ${JSON.stringify(modulesArray)}
+missing = []
+for m in mods:
+    try:
+        importlib.import_module(m)
+    except Exception:
+        missing.append(m)
+if missing:
+    await micropip.install(missing)
+`;
+      await pyodide.runPythonAsync(installerCode);
+    }
+
+    // --- Execute the (possibly rewritten) code ---
+    try {
+      const output = await pyodide.runPythonAsync(code);
+      this.conductor.sendResult(output);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.conductor.sendError(new ConductorError(message));
+    }
+  }
+}
+
+export class ChapterPyodideEvaluator extends PyodideEvaluator {
+  private chapter: number;
+
+  constructor(conductor: IRunnerPlugin, chapter: number) {
+    super(conductor);
+    this.chapter = chapter;
+  }
+
+  protected validateChunk(chunk: string): void {
+    const script = chunk + "\n";
+    const ast = parse(script);
+    analyze(ast, script, this.chapter);
+  }
+}
+
+export class PyodideEvaluator1 extends ChapterPyodideEvaluator {
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor, 1);
+  }
+}
+
+export class PyodideEvaluator2 extends ChapterPyodideEvaluator {
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor, 2);
+  }
+}
+
+export class PyodideEvaluator3 extends ChapterPyodideEvaluator {
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor, 3);
+  }
+}
+
+export class PyodideEvaluator4 extends ChapterPyodideEvaluator {
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor, 4);
+  }
+}
+
+export class PyodideEvaluatorFull extends PyodideEvaluator {
+  constructor(conductor: IRunnerPlugin) {
+    super(conductor);
+  }
+
+  protected validateChunk(_chunk: string): void {
+    // No-op validation
+  }
+}