Add asyncpy decorator and transpiles await expression and async code block

Author: rafi16jan

index.js

@@ -51,7 +51,11 @@ module.exports = (async () => {
   const methods = {}
   methods.init = global.mp_js_init;
   const do_str = global.mp_js_do_str;
+  global._mp_js_do_str = do_str;
   methods.do_str = async (code, concurrent) => {
+    code = code.replace(/async {/g, 'async_py(lambda **kwargs: """').replace(/} async/g, '""")');
+    //code = code.replace(/async {/g, 'exec("""').replace(/} async/g, '""")');
+    code = code.replace(/:async:/g, 'return """').replace(/return async/g, '"""');
     const codes = code.split('\n');
     let spaces = '';
     for (let line of codes) {
@@ -65,7 +69,7 @@ module.exports = (async () => {
       break;
     }
     if (spaces || concurrent) {
-      if (concurrent) spaces = ' ';
+      if (concurrent && !spaces) spaces = ' ';
       let index_split = 0;
       const new_code = [];
       for (let line of codes) {
@@ -77,14 +81,18 @@ module.exports = (async () => {
         let code_cache = [];
         for (var each of new_code) {
           let await_code;
-          if (each.indexOf(' = wait(') > -1) {
+          if (each.indexOf('await ') > -1) each = each.replace('await', 'wait(') + ')';
+          if (each.indexOf('wait(') > -1 && each.indexOf('def wait(promise') < 0) {
             if (code_cache.length > 0) {
               result.push(await global.mp_js_do_str(code_cache.join('\n'), false));
               code_cache = [];
             }
-            const [variable, wait] = each.split(' = ')
-            const promise = wait.slice(5, -1);
-            await_code = variable + ' = ' + promise + '._value';
+            
+            if (each.indexOf(' = wait(') > -1) {
+              const [variable, wait] = each.split(' = ')
+              const promise = wait.slice(5, -1);
+              await_code = variable + ' = ' + promise + '._value';
+            }
           }
           else {
             code_cache.push(each);

js.py

@@ -5,6 +5,12 @@
 funcache = {}
 procache = {}
 
+#Javascript's JSON Types for eliminating json.loads
+true = True
+false = False
+null = None
+undefined = None
+
 def js_exec(code, *args):
     code = format(code, *args)
     return js.exec('(async () => {\n' + code + '\n})();')
@@ -24,24 +30,22 @@ def format(string, *args):
 
 def wait(promise):
     procache[promise._name] = promise
-    #js.exec('console.log("function")')
-    js.exec("""
-      //console.log('exec');
+    js_exec("""
       global.promiseWaitInterval = setInterval(() => {
-        //console.log('interval')
         const object = global.mpjscache['{0}'];
-        console.log(object)
+        //console.log(object)
         if (object && object.constructor !== Promise) {
           clearInterval(global.promiseWaitInterval);
           global.promiseWaitInterval = undefined;
           global.mp_js_do_str(`
             import js
             procache['{0}']._resolved = True
+            procache['{0}']._value = JS('global.mpjscache["{0}"]')
             procache['{0}'] = procache['{0}']._value
           `);
         }
       }, 500);
-    """.replace('{0}', promise._name))
+    """, promise._name)
     exit
 
 def resolve(cache, name, value):
@@ -51,6 +55,20 @@ def resolve(cache, name, value):
     else:
        cache[name] = value
 
+async_id = 0
+
+def async_py(function):
+    def wrap(**kwargs):
+        code_string = function(**kwargs)
+        for key in kwargs:
+            if key not in code_string: continue
+            async_id += 1
+            asycache[async_id] = kwargs[key]
+            code_string = code_string.replace(key, 'asycache[%s]' % (async_id))
+        exec(code_string)
+        exit
+    return wrap
+
 class JSPromise():
 
     def __init__(self, name):
@@ -69,9 +87,13 @@ def __init__(self, name):
         self._name = name
 
     def __len__(self):
-        return 1
+        if self._name:
+           return 1
+        else:
+           return 0
 
     def __dir__(self):
+        if not self._name: return []
         js_exec("""
           let keys = JSON.stringify(Object.keys({0}));
           global.mp_js_do_str(`
@@ -82,7 +104,7 @@ def __dir__(self):
         return dircache.get(self._name, [])
 
     def __getattr__(self, key):
-        name = self._name + '.' + key
+        name = self._name + '.' + key if self._name else key
         js_exec("""
           let object = {0};
           if (object && object.constructor === Promise) {
@@ -108,7 +130,7 @@ def __getattr__(self, key):
             return global.mp_js_do_str(`
               import js
               import json
-              resolve(objcache, '{0}', json.loads('''${object}'''))
+              resolve(objcache, '{0}', ${object})
             `);
           }
           catch(error) {
@@ -121,6 +143,7 @@ def __getattr__(self, key):
         return objcache.get(name)
 
     def __setattr__(self, key, value):
+        if not self._name: return
         value = json.dumps(value)
         object_name = self._name + '.' + key
         js_exec("""
@@ -164,7 +187,7 @@ def function(*args):
             return global.mp_js_do_str(`
               import js
               import json
-              resolve(funcache, '{0}', json.loads('''${object}'''))
+              resolve(funcache, '{0}', ${object})
             `);
           }
           catch(error) {
@@ -178,56 +201,22 @@ def function(*args):
     return function
 
 def JS(variable):
-    js_exec("""
-      let object = {0};
-      if (object && object.constructor === Promise) {
-        await global.mp_js_do_str(`
-          import js
-          objcache['{0}'] = JSPromise('{0}')
-        `)
-        object = await object;
-      }
-      try {
-        if (object && [Array, Object, Number, String, Boolean, Function, AsyncFunction].indexOf(object.constructor) < 0) throw Error('Not JSON Serializable');
-        if (object && object.constructor === Object) for (let key in Object.keys({0})) {
-          if (object.indexOf(value) < 0) throw Error('Not a JSON');
-        }
-        else if (object && (object.constructor === Function || object.constructor === AsyncFunction)) {
-          delete global.mpjscache['{0}'];
-          return global.mp_js_do_str(`
-            import js
-            resolve(objcache, '{0}', JSFunction('{0}'))
-          `);
-        }
-        object = object !== undefined ? JSON.stringify(object) : 'null';
-        return global.mp_js_do_str(`
-          import js
-          import json
-          resolve(objcache, '{0}', json.loads('''${object}'''))
-       `);
-      }
-      catch(error) {
-        return global.mp_js_do_str(`
-          import js
-          resolve(objcache, '{0}', JSObject('{0}'))
-        `);
-      }
-    """, variable)
-    return objcache.get(variable)
+    empty = JSObject('')
+    return getattr(empty, variable)
 
 #require = JS('require')
 #result = require('fs').readFileSync('./test.js').toString()
 #print(result)
 
 #This code block is adaptable to Javascript's event loop
-#exec("""
+async {
 
-#require = JS('require')
-#response = require('node-fetch')('https://github.com/')
-#response = wait(response)
-#print(response)
-#result = response.text()
-#result = wait(result)
-#print(result)
+require = JS('require')
+response = require('node-fetch')('https://github.com/')
+response = await response
+print(response)
+result = response.text()
+result = await result
+print(result)
 
-#""")
+} async ()