support python powerrun

Author: lihebi

cpkernel/kernels/python/codepod.py

@@ -1264,28 +1264,66 @@ def code2parts(code):
     else:
         return [unparse(ast1.body[:-1]), expr]
 
+from collections import defaultdict
 
-def _make_codepod():
-    d = {}
+d = {}
 
-    def getmod(ns):
-        if ns not in d:
-            d[ns] = types.ModuleType(ns)
-            # for testing purpose
-            d[ns].__dict__["CODEPOD_GETMOD"] = getmod
-        return d[ns]
+"""
+here's the new plan for python's eval
 
-    def eval_func(code, ns):
-        # the codepod(code) is the program sent to backend
-        # codepod is defined on the kernel
-        mod = getmod(ns)
-        [stmt, expr] = code2parts(code)
-        if stmt:
-            exec(stmt, mod.__dict__)
-        if expr:
-            return eval(expr, mod.__dict__)
+Python's module is closely bound to the file system, so it is not possible to use that.
 
-    return eval_func, getmod
+I have to use my own globals and locals during exec/eval.
 
+Then, I'll just record the calling relationships for the modules. When evaluating, I'll:
 
-CODEPOD_EVAL, CODEPOD_GETMOD = _make_codepod()
+1. eval_func(code, nses)
+    - nses is a list of namespaces in order, the last one is this ns
+    - that should be it. The question is where to compute nses. I would
+        1. compute it when powerRunTree
+        2. let the kernel knows it by using CODEPOD_ADD_IMPORT. The kernel will record this.
+"""
+
+# from ns to nses that should imported
+import_d = defaultdict(set)
+# from ns to exported names
+export_d = defaultdict(set)
+# from ns to subdeck nses
+export_sub_d = defaultdict(set)
+
+def CODEPOD_GETMOD(ns):
+    if ns not in d:
+        d[ns] = types.ModuleType(ns)
+    return d[ns]
+
+def merge_dicts(dicts):
+    """
+    Given any number of dictionaries, shallow copy and merge into a new dict,
+    precedence goes to key-value pairs in latter dictionaries.
+    """
+    result = {}
+    for dictionary in dicts:
+        result.update(dictionary)
+    return result
+
+def CODEPOD_ADD_IMPORT(FROM, TO):
+    import_d[TO].add(FROM)
+def CODEPOD_REMOVE_IMPORT(FROM, TO):
+    if FROM in import_d[TO]:
+        import_d[TO].remove(FROM)
+def CODEPOD_SET_EXPORT(ns, exports):
+    export_d[ns] = exports
+def CODEPOD_SET_EXPORT_SUB(ns, nses):
+    export_sub_d[ns] = nses
+
+def CODEPOD_EVAL(code, ns):
+    # the codepod(code) is the program sent to backend
+    # codepod is defined on the kernel
+    mod = CODEPOD_GETMOD(ns)
+    [stmt, expr] = code2parts(code)
+    _dict = merge_dicts([{k:v for k,v in CODEPOD_GETMOD(x).__dict__.items() if k in export_d[x]} for x in import_d[ns]]
+                      + [{k:v for k,v in CODEPOD_GETMOD(x).__dict__.items() if k in export_d[x]} for ns1 in export_sub_d[ns] for x in import_d[ns1]])
+    if stmt:
+        exec(stmt, _dict, mod.__dict__)
+    if expr:
+        return eval(expr, _dict, mod.__dict__)

ui/src/lib/ws/middleware.js

@@ -242,6 +242,71 @@ ${nses
         },
       })
     );
+  } else if (pod.lang === "python") {
+    // python powerrun
+    // 1. create the module
+    let names = pod.children
+      .filter(({ id }) => pods[id].type !== "DECK")
+      .filter(({ id }) => pods[id].exports)
+      .map(({ id }) =>
+        Object.entries(pods[id].exports)
+          .filter(([k, v]) => v)
+          .map(([k, v]) => k)
+      );
+    names = [].concat(...names);
+    let nses = getUtilNs({ id, pods });
+    const child_deck_nses = pods[id].children
+      .filter(({ id }) => pods[id].type === "DECK" && !pods[id].thundar)
+      .map(({ id, type }) => pods[id].ns);
+    nses = nses.concat(child_deck_nses);
+    // if it is a test desk, get parent
+    if (pod.thundar) {
+      nses.push(pods[pod.parent].ns);
+    }
+
+    // exported subdecks
+    // TODO handle this in python,
+    // In racket: all-from-out
+    // In julia: @reexport
+    let exported_decks = pods[id].children
+      .filter(
+        ({ id }) =>
+          pods[id].type === "DECK" &&
+          pods[id].exports &&
+          pods[id].exports["self"]
+      )
+      .map(({ id, type }) => pods[id].ns);
+    // 2. import the namespaces
+    let code = `${nses
+      .map(
+        (ns) => `
+CODEPOD_ADD_IMPORT("${ns}", "${pod.ns}")`
+      )
+      .join("\n")}
+
+CODEPOD_SET_EXPORT("${pod.ns}", {${names.map((name) => `"${name}"`).join(",")}})
+
+CODEPOD_SET_EXPORT_SUB("${pod.ns}", {${exported_decks
+      .map((name) => `"${name}"`)
+      .join(",")}})
+    `;
+    // console.log("==== PYTHON CODE", code);
+    storeAPI.dispatch(repoSlice.actions.clearResults(pod.id));
+    storeAPI.dispatch(repoSlice.actions.setRunning(pod.id));
+    socket.send(
+      JSON.stringify({
+        type: "runCode",
+        payload: {
+          lang: pod.lang,
+          code,
+          // namespace: pod.ns,
+          raw: true,
+          // FIXME this is deck's ID
+          podId: pod.id,
+          sessionId: storeAPI.getState().repo.sessionId,
+        },
+      })
+    );
   }
   if (doEval) {
     // run all children pods