Setup new execution path for Python AST (Refs #51)

* Updated index.ts with runPyAST (Python AST -> CSE)

* py_interpreter.ts in CSE (to replace interpreter.ts in the future)

* PyRunCSEMachine in pyRunner.ts

* naming convention for files/functions to replace old logic will start
  with "Py" --  to be renamed after full migration

Author: lucasnyc

src/cse-machine/py_interpreter.ts

@@ -0,0 +1,27 @@
+import { Context } from "./context";
+import { CSEBreak, Representation, Result, Finished } from "../types";
+import { StmtNS } from "../ast-types";
+import { Value, ErrorValue } from "./stash";
+
+type Stmt = StmtNS.Stmt;
+
+export function PyCSEResultPromise(context: Context, value: Value): Promise<Result> {
+    return new Promise((resolve, reject) => {
+        if (value instanceof CSEBreak) {
+            resolve({ status: 'suspended-cse-eval', context });
+        } else if (value.type === 'error') {
+            const errorValue = value as ErrorValue;
+            const representation = new Representation(errorValue.message);
+            resolve({ status: 'finished', context, value, representation } as Finished);
+        } else {
+            const representation = new Representation(value);
+            resolve({ status: 'finished', context, value, representation } as Finished);
+        }
+    });
+}
+
+export function PyEvaluate(code: string, program: Stmt, context: Context): Promise<Result> {
+    // dummy for now, just to test getting AST from parser
+    const dummyValue = { type: 'NoneType', value: undefined };
+    return PyCSEResultPromise(context, dummyValue);
+}

src/index.ts

@@ -141,6 +141,10 @@ import { runCSEMachine } from "./runner/pyRunner";
 import { initialise } from "./conductor/runner/util/initialise";
 import { PyEvaluator } from "./conductor/runner/types/PyEvaluator";
 export * from './errors';
+import { PyRunCSEMachine } from "./runner/pyRunner";
+import { StmtNS } from "./ast-types";
+
+type Stmt = StmtNS.Stmt;
 
 export function parsePythonToEstreeAst(code: string,
     variant: number = 1,
@@ -205,4 +209,52 @@ export async function runInContext(
     return result;
 }
 
-const {runnerPlugin, conduit} = initialise(PyEvaluator);
+
+
+export async function runPyAST(
+    code: string,
+    context: Context,
+    options: RecursivePartial<IOptions> = {}
+): Promise<Result> {
+    const script = code + "\n";
+    const tokenizer = new Tokenizer(script);
+    const tokens = tokenizer.scanEverything();
+    const pyParser = new Parser(script, tokens);
+    const ast = pyParser.parse();
+    const result = PyRunCSEMachine(code, ast, context, options);
+    return result;
+};
+
+// const {runnerPlugin, conduit} = initialise(PyEvaluator);
+export * from "./errors";
+import * as fs from "fs";
+
+
+if (require.main === module) {
+    (async () => {
+      if (process.argv.length < 3) {
+        console.error("Usage: npm run start:dev -- <python-file>");
+        process.exit(1);
+      }
+      const options = {};
+      const context = new Context();
+
+      const filePath = process.argv[2];
+  
+      try {
+        //await loadModulesFromServer(context, "http://localhost:8022");
+
+        const code = fs.readFileSync(filePath, "utf8") + "\n";
+        console.log(`Parsing Python file: ${filePath}`);
+  
+        const result = await runInContext(code, context, options);
+        console.info(result);
+        console.info((result as Finished).value);
+        console.info((result as Finished).representation.toString((result as Finished).value));
+  
+      } catch (e) {
+        console.error("Error:", e);
+      }
+
+    })();
+}

src/runner/pyRunner.ts

@@ -3,8 +3,16 @@ import { Context } from "../cse-machine/context"
 import { CSEResultPromise, evaluate } from "../cse-machine/interpreter"
 import { RecursivePartial, Result } from "../types"
 import * as es from 'estree'
+import { PyEvaluate } from "../cse-machine/py_interpreter"
+import { StmtNS } from "../ast-types";
 
 export function runCSEMachine(code: string, program: es.Program, context: Context, options: RecursivePartial<IOptions> = {}): Promise<Result> {
     const result = evaluate(code, program, context, options);
     return CSEResultPromise(context, result);
-}
+}
+
+type Stmt = StmtNS.Stmt;
+
+export function PyRunCSEMachine(code: string, program: Stmt, context: Context, options: RecursivePartial<IOptions> = {}): Promise<Result> {
+    return PyEvaluate(code, program, context);
+}