Setup new execution path for Python AST [Refs #51][1]

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

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

* PyRunCSEMachine in pyRunner.ts

* added local.test.ts to gitignore

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

Author: lucasnyc

.gitignore

@@ -107,4 +107,7 @@ dist
 .idea
 
 # TypeScript build files
-build/
+build/
+
+# Ignore personal test files
+*.local.test.ts

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,20 @@ 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);

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);
+}