pytwojs 1.0.0__py3-none-any.whl

pytwojs/__init__.py

@@ -0,0 +1,26 @@
+__package__ = 'pytwojs'
+
+from typing import Union as _Union
+from .interpreter import NodeInterpreter as _NodeInterpreter
+
+
+class Context(_NodeInterpreter):
+
+    def exec(self, code: _Union[str, bytes]):
+        if isinstance(code, str):
+            code = code.encode("utf-8")
+        super().exec(code)
+
+    def eval(self, code: _Union[str, bytes]):
+        if isinstance(code, str):
+            code = code.encode("utf-8")
+        return super().eval(code)
+
+
+def compile_(code: _Union[str, bytes]) -> Context:
+    if isinstance(code, str):
+        code = code.encode("utf-8")
+
+    ctx = Context()
+    ctx.exec(code)
+    return ctx

pytwojs/_program.py

@@ -0,0 +1,46 @@
+PROGRAM = """
+const repl = require('node:repl');
+function toString(obj){return Object.prototype.toString.call(obj)}
+function isClass(obj) {
+  if (typeof obj !== 'function') return false;
+  if (!obj.prototype) return false;
+  const descriptor = Object.getOwnPropertyDescriptor(obj, 'prototype');
+  if (descriptor?.writable !== false) return false;
+  let isCallable = false
+  try {
+    Reflect.construct(obj, [], obj);
+    isCallable = true
+  } catch (e) {
+    return false;
+  }
+  const isNativeClass = Function.prototype.toString.call(obj).startsWith('class');
+  const isBuiltin = obj.name in globalThis;
+  return isNativeClass || isBuiltin || isCallable;
+}
+const replServer = repl.start({
+  prompt: '',
+  writer: (output) => {
+    switch (toString(output)) {
+      case "[object Undefined]":
+        return `{"stringify":"${JSON.stringify(output)}","toString":"${toString(output)}","exception":0}`;
+      case "[object Error]":
+        return `{"stringify":${JSON.stringify(output)},"toString":"${output.toString()}","exception":1}`;
+      case "[object Function]":
+        if (!isClass(output))
+          return `{"stringify":"${JSON.stringify(output)}","toString":"[Function: ${output.name}]","exception":0}`;
+        return `{"stringify":"${JSON.stringify(output)}","toString":"[class ${output.name}]","exception":0}`;
+      case "[object AsyncFunction]":
+        return `{"stringify":"${JSON.stringify(output)}","toString":"[AsyncFunction: ${output.name}]","exception":0}`;
+    }
+    try {
+      return `{"stringify":${JSON.stringify(output)},"toString":"${output.toString()}","exception":0}`;
+    } catch (e) {
+      return `{"stringify":"${toString(output)}","toString":"${toString(output)}","exception":0}`;
+    }
+  }
+});
+"""
+
+FLAGS = "-e"
+EXEC_END_FLAGS = b"'[[[______<<<exec_done>>>______]]]'\n"
+EXEC_DONE_FLAGS = "[[[______<<<exec_done>>>______]]]"

pytwojs/exceptions.py

@@ -0,0 +1,6 @@
+class JSError(Exception):
+    pass
+
+
+class JSException(JSError):
+    pass

pytwojs/interpreter.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+__package__ = "pytwojs"
+
+import json
+import subprocess
+import typing
+import threading
+import time
+import uuid
+import weakref
+
+from .utils import make_cmd
+from .exceptions import JSException
+from ._program import EXEC_END_FLAGS, EXEC_DONE_FLAGS
+
+
+def _generate_name() -> str:
+    return f"__{str(int(time.time() * 1000000))}{uuid.uuid4().hex[:16]}"
+
+
+def _close(node) -> None:
+    return_code = node.poll()
+    if return_code is None:
+        node.stdin.close()
+        node.stdout.close()
+        node.wait()
+
+
+class NodeInterpreter:
+
+    def __init__(self) -> None:
+        cmd = make_cmd()
+        self._node = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        self._global_interpreter_lock = threading.Lock()
+        self._finalizer = weakref.finalize(self, _close, self._node)
+
+    def exec(self, code: bytes) -> None:
+        """
+        Execute the given JavaScript code(multi line)
+        :param code: bytes
+        :return: None
+        """
+        with self._global_interpreter_lock:
+            self._write(code + b"\n")
+            self._flush()
+            self._write(EXEC_END_FLAGS)
+            self._flush()
+            while out := self._readline():
+                try:
+                    out_obj = json.loads(out)
+                    if isinstance(out_obj, dict):
+                        if out_obj.get("stringify") == EXEC_DONE_FLAGS:
+                            break
+                except json.JSONDecodeError:
+                    pass
+
+    def eval(self, code: bytes) -> JSProxyWrapper:
+        """
+        Execute single line JS expression or Get JavaScript object
+        :param code: JavaScript single line expression
+        :return: JSProxyWrapper
+        """
+        with self._global_interpreter_lock:
+            self._write(code + b"\n")
+            self._flush()
+            result = self._reach_result_line()
+
+        if result[:8] == b"Uncaught":
+            py_obj = json.loads(result.removeprefix(b"Uncaught").strip())
+            raise JSException(py_obj['toString'])
+
+        return JSProxyWrapper(self, result, code.strip())
+
+    def _reach_result_line(self) -> bytes:
+        while out := self._readline():
+            out_cpy = out.strip()
+            if out_cpy[:8] == b"Uncaught":
+                return out_cpy
+            try:
+                pyobj = json.loads(out_cpy)
+                if isinstance(pyobj, dict):
+                    if len(pyobj.keys()) == 3:
+                        try:
+                            _ = pyobj['stringify'] and pyobj['toString'] and pyobj['exception']
+                            return out_cpy
+                        except KeyError:
+                            pass
+            except json.JSONDecodeError:
+                pass
+
+    @property
+    def is_closed(self):
+        return_code = self._node.poll()
+        if return_code is not None:
+            return True
+        return False
+
+    def close(self) -> None:
+        self._finalizer()
+
+    def _write(self, code: bytes):
+        self._node.stdin.write(code)
+
+    def _flush(self):
+        self._node.stdin.flush()
+
+    def _readline(self):
+        return self._node.stdout.readline()
+
+    def __enter__(self) -> NodeInterpreter:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+
+class JSProxyWrapper:
+
+    def __init__(self, node: NodeInterpreter, js_result: bytes, name: bytes) -> None:
+        self._node_repl = node
+        self._js_result = js_result
+        self._name = name
+        self._lock = node._global_interpreter_lock
+
+    def _eval(self, code: bytes, is_obj=False) -> JSProxyWrapper:
+        with self._lock:
+            if not is_obj:
+                self._node_repl._write(self._name + b"." + code + b"\n")
+            else:
+                name = _generate_name().encode("utf-8")
+                self._node_repl._write(name + b"=" + code + b"\n")
+            self._node_repl._flush()
+            result = self._node_repl._reach_result_line()
+
+        if result[:8] == b"Uncaught":
+            pyobj = json.loads(result.removeprefix(b"Uncaught").strip())
+            raise JSException(pyobj['toString'])
+
+        if not is_obj:
+            return JSProxyWrapper(self._node_repl, result, self._name + b"." + code.strip())
+        return JSProxyWrapper(self._node_repl, result, name)
+
+    def call(self, func: str, *args) -> JSProxyWrapper:
+        """Call functions within the object itself"""
+        call_js_str = f"{func}(...{json.dumps(args)})".encode("utf-8")
+        return self._eval(call_js_str)
+
+    def __getattr__(self, name) -> JSProxyWrapper:
+        return self._eval(name.encode('utf-8'))
+
+    def __call__(self, *args, **kwargs) -> JSProxyWrapper:
+        pyobj = json.loads(self._js_result)
+        if pyobj['toString'][1:14] == "AsyncFunction":
+            call_js_str = f"(await {self._name.decode('utf-8')}(...{json.dumps(args)}))".encode("utf-8")
+        elif pyobj['toString'][1:6] == "class":
+            call_js_str = f"new {self._name.decode('utf-8')}(...{json.dumps(args)})".encode("utf-8")
+        else:
+            call_js_str = f"{self._name.decode('utf-8')}(...{json.dumps(args)})".encode("utf-8")
+
+        return self._eval(call_js_str, True)
+
+    @property
+    def _value(self) -> bytes:
+        return self._js_result
+
+    @property
+    def pyobj(self) -> typing.Any:
+        """Get python object"""
+        result = json.loads(self._js_result)
+        if result['stringify'] == "undefined":
+            return None
+
+        return result['stringify']

pytwojs/utils.py

@@ -0,0 +1,14 @@
+import os
+from ._program import PROGRAM, FLAGS
+
+
+def get_node_env():
+    node = os.environ.get('NODE_PATH') if os.environ.get('NODE_PATH') else os.environ.get('NODE')
+    if not node:
+        return "node"
+    return node
+
+
+def make_cmd():
+    node = get_node_env()
+    return [node, FLAGS, PROGRAM]

pytwojs-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: pytwojs
+Version: 1.0.0
+Summary: A high-performance Python library that relies on nodejs to execute JavaScript
+Author: Samwe
+Author-email: 1281722462@qq.com
+Requires-Python: >=3.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: requires-python
+Dynamic: summary

pytwojs-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytwojs/__init__.py,sha256=qOhwd6-MsPv8HjVSoYT00Xo4ceyEerRcn9cYCurIXio,659
+pytwojs/_program.py,sha256=i-NOLgPfdpYDlB72S_D2NaSTRlxTZRXeB9kaIOliQXE,1905
+pytwojs/exceptions.py,sha256=EDZJ-HRop2I3u4jP6qFWI0KQjhN_0WxCQZPD9JCMiJE,80
+pytwojs/interpreter.py,sha256=PkSQ7lyfBoydH8zVgzOZVBj5y6KL5GR8ximhSwK3P2s,5809
+pytwojs/utils.py,sha256=Z9CXMicohjRpR8hmdYoJXxXOnmdfEPWG-Oau59ICgq8,314
+pytwojs-1.0.0.dist-info/METADATA,sha256=0CRCf_F0SW1xbPXsHPG41reHp6ZVIz73igwpK6Zjri8,300
+pytwojs-1.0.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pytwojs-1.0.0.dist-info/top_level.txt,sha256=h1Jc5V_4aAsbVlzO4SIwZ_dEOFgxG4amrXCfYyHPDj0,8
+pytwojs-1.0.0.dist-info/RECORD,,

pytwojs-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytwojs-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytwojs