pyevaljs4 0.1.0__tar.gz

pyevaljs4-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.2
+Name: pyevaljs4
+Version: 0.1.0
+Summary: A high-performance Python library that relies on nodejs to execute JavaScript
+Home-page: https://github.com/Smawexi/PyEvalJS4
+Author: Samwe
+Author-email: 1281722462@qq.com
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7.0
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+### A high-performance Python library that relies on nodejs to execute JavaScript
+
+---
+
+### Environments
+
+**Please note that you need to install Node.js and set up the NODE_PATH or NODE environment variable properly!**  
+*If not set, the default will use the Node.js in the system's path.*
+
+---
+
+### Quickstart
+```python
+import pyevaljs4
+
+# example 1
+rt = pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == "xy"
+# Another way of passing parameters
+res = rt.call('f', arg_list=['x', 'y'])
+print(res)
+assert res == "xy"
+# Other equivalent calling methods
+print(rt.f('x',  'y'))
+print(rt.f(arg_list=['x', 'y']))
+# close runtime
+rt.close()
+
+# example 2
+with pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}") as rt:
+    res = rt.call('f', 'x', 'y')
+    print(res)
+    assert res == "xy"
+
+# example 3
+# empty context
+rt = pyevaljs4.compile_()
+# Add the function f to this context
+rt.eval("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == 'xy'
+# Other calling methods
+res = rt.eval("f('x', 'y')")
+print(res)
+assert res == "xy"
+rt.close()
+
+# example 4
+# Call JS asynchronous function
+rt = pyevaljs4.compile_()
+rt.eval("async function f(a,b){console.log(a,b);return a+b;}")
+# To call the JS asynchronous function, you need to pass async_js_func=True
+res = rt.call('f', 'x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+res = rt.f('x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+# The shortcut for calling the JS asynchronous function can only be used this way.
+# other cases are not supported.
+res = rt.eval('await f("x", "y")')
+print(res)
+assert res == "xy"
+rt.close()
+```
+---
+
+### Use a custom version of Node.js
+- By setting environment variables to use a custom version of Node, you only need to set the NODE_PATH or NODE environment variables.  
+
+```python
+import os
+# Highest priority
+os.environ['NODE_PATH'] = '/path/to/node.exe'
+
+# Second priority
+os.environ['NODE'] = '/path/to/node.exe'
+```

pyevaljs4-0.1.0/README.md

@@ -0,0 +1,81 @@
+### A high-performance Python library that relies on nodejs to execute JavaScript
+
+---
+
+### Environments
+
+**Please note that you need to install Node.js and set up the NODE_PATH or NODE environment variable properly!**  
+*If not set, the default will use the Node.js in the system's path.*
+
+---
+
+### Quickstart
+```python
+import pyevaljs4
+
+# example 1
+rt = pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == "xy"
+# Another way of passing parameters
+res = rt.call('f', arg_list=['x', 'y'])
+print(res)
+assert res == "xy"
+# Other equivalent calling methods
+print(rt.f('x',  'y'))
+print(rt.f(arg_list=['x', 'y']))
+# close runtime
+rt.close()
+
+# example 2
+with pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}") as rt:
+    res = rt.call('f', 'x', 'y')
+    print(res)
+    assert res == "xy"
+
+# example 3
+# empty context
+rt = pyevaljs4.compile_()
+# Add the function f to this context
+rt.eval("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == 'xy'
+# Other calling methods
+res = rt.eval("f('x', 'y')")
+print(res)
+assert res == "xy"
+rt.close()
+
+# example 4
+# Call JS asynchronous function
+rt = pyevaljs4.compile_()
+rt.eval("async function f(a,b){console.log(a,b);return a+b;}")
+# To call the JS asynchronous function, you need to pass async_js_func=True
+res = rt.call('f', 'x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+res = rt.f('x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+# The shortcut for calling the JS asynchronous function can only be used this way.
+# other cases are not supported.
+res = rt.eval('await f("x", "y")')
+print(res)
+assert res == "xy"
+rt.close()
+```
+---
+
+### Use a custom version of Node.js
+- By setting environment variables to use a custom version of Node, you only need to set the NODE_PATH or NODE environment variables.  
+
+```python
+import os
+# Highest priority
+os.environ['NODE_PATH'] = '/path/to/node.exe'
+
+# Second priority
+os.environ['NODE'] = '/path/to/node.exe'
+```

pyevaljs4-0.1.0/pyevaljs4/__init__.py

@@ -0,0 +1,21 @@
+__package__ = 'pyevaljs4'
+
+from .pyevaljs import RunTime, JSException, RunTimeNotFoundException
+from .__version__ import version
+
+
+def compile_(js_code: str = None, mode: str = None):
+    """
+    Compile js code
+    :param js_code: js source code
+    :param mode: Execution mode, the default is '.js', meaning it will execute with '.js' behavior.
+                Other optional values include '.cjs' and '.mjs', etc.
+    :return: RunTime
+    """
+    if js_code is None:
+        js_code = ""
+
+    if mode is None:
+        mode = ".js"
+
+    return RunTime._compile(js_code, mode)

pyevaljs4-0.1.0/pyevaljs4/__version__.py

@@ -0,0 +1 @@
+version = ".".join(map(str, (0, 1, 0)))

pyevaljs4-0.1.0/pyevaljs4/_program.py

@@ -0,0 +1,50 @@
+NODE_PROGRAM = """
+try {{
+    var __process = process;  
+}} catch (e) {{
+    console.log('[[<<exception>>]]' + JSON.stringify(e.stack));
+}}
+try {{
+    globalThis.require = require;
+    globalThis.exports = exports;
+    globalThis.module = module;
+    globalThis.__filename = __filename;
+    globalThis.__dirname = __dirname;
+}} catch (e) {{}}
+try {{
+   globalThis.eval({source}); 
+}} catch (e) {{
+    console.log('[[<<exception>>]]' + JSON.stringify(e.stack));
+}}
+__process.stdin.setEncoding('utf8');
+__process.stdin.on('data', function(data) {{
+    let input = data.trim();
+    try {{
+        if (input.substring(0, 24) === "[[PyEvalJS4_Async_Call]]"){{
+            globalThis.eval(input.substring(24))
+        }} else {{
+            var res = globalThis.eval(input)
+            console.log('[[<<result>>]]' + JSON.stringify(res))
+        }}
+    }} catch (e) {{
+        console.log('[[<<exception>>]]' + JSON.stringify(e.stack))
+    }}
+}});
+__process.on('uncaughtException', (err) => {{
+    console.log('[[<<exception>>]]' + err);
+}});
+"""
+
+ASYNC_EVAL = """
+(async () => {{
+    try {{
+        let res = {};
+        console.log('[[<<result>>]]' + JSON.stringify(res));
+    }} catch (e) {{
+        console.log('[[<<exception>>]]' + JSON.stringify(e.stack))
+    }}
+}})();
+"""
+
+ASYNC_CALL = "{flags}{func}.apply(this, {args}).then(res => {{console.log('[[<<result>>]]' + JSON.stringify(res))}}, err => {{console.log('[[<<exception>>]]' + JSON.stringify(err.stack))}})"
+SYNC_CALL = "{func}.apply(this, {args})"

pyevaljs4-0.1.0/pyevaljs4/exceptions.py

@@ -0,0 +1,7 @@
+class JSException(Exception):
+    pass
+
+
+class RunTimeNotFoundException(Exception):
+    pass
+

pyevaljs4-0.1.0/pyevaljs4/pyevaljs.py

@@ -0,0 +1,145 @@
+__package__ = 'pyevaljs4'
+
+import logging
+import json
+import os
+import subprocess
+import tempfile
+import weakref
+import threading
+from typing import Any
+from functools import partial
+
+from .exceptions import JSException, RunTimeNotFoundException
+from ._program import NODE_PROGRAM, ASYNC_EVAL, ASYNC_CALL, SYNC_CALL
+from .utils import get_node_env
+from .settings import ASYNC_CALL_FLAGS
+
+_logger = logging.getLogger('pyevaljs4')
+
+
+class RunTime:
+
+    def __init__(self):
+        self._node = None
+        self._node_env = get_node_env()
+        self._path = None
+        self._initialize = False
+        self._finalizer = None
+        self._lock = threading.Lock()
+
+    def _init(self):
+        with self._lock:
+            if not self._initialize:
+                try:
+                    self._node = subprocess.Popen(
+                        [self._node_env, self._path],
+                        stdin=subprocess.PIPE,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        universal_newlines=True,
+                        encoding='utf-8'
+                    )
+                except Exception as e:
+                    os.remove(self._path)
+                    raise RunTimeNotFoundException("RunTime(nodejs) not found error") from e
+
+                self._finalizer = weakref.finalize(self, self._close)
+                self._initialize = True
+
+    @classmethod
+    def _compile(cls, source: str, suffix: str):
+        self = cls()
+        fd, path = tempfile.mkstemp(suffix=suffix, dir='.')
+        with open(fd, 'w', encoding='utf-8') as fp:
+            fp.write(NODE_PROGRAM.format(source=json.dumps(source)))
+        self._path = path
+        self._init()
+        return self
+
+    def eval(self, code: str) -> Any:
+        if not code:
+            return
+
+        if code[:5] == 'await':
+            return self._async_eval(code)
+
+        return self._eval(code)
+
+    def _eval(self, code: str):
+        return self._execute(statement=code)
+
+    def _async_eval(self, code: str):
+        statement = ASYNC_CALL_FLAGS + ASYNC_EVAL.format(code)
+        return self._execute(statement)
+
+    def call(self, func: str, *args, arg_list: list = None, async_js_func=False) -> Any:
+        if arg_list is not None:
+            _args = arg_list
+        else:
+            _args = [arg for arg in args]
+
+        return self._call(func, _args, async_js_func)
+
+    def _call(self, func: str, args: list, async_js_func=False):
+        if async_js_func:
+            statement = ASYNC_CALL.format(flags=ASYNC_CALL_FLAGS, func=func, args=args)
+        else:
+            statement = SYNC_CALL.format(func=func, args=args)
+
+        return self._execute(statement=statement)
+
+    def _execute(self, statement: str):
+        with self._lock:
+            self._node.stdin.write(statement)
+            self._node.stdin.flush()
+            result = self._get_result()
+
+        if result["exception"]:
+            raise JSException(result['exception'])
+
+        return result['result']
+
+    def _get_result(self):
+        _result = {'result': None, 'exception': None}
+        while True:
+            out = self._node.stdout.readline()
+            if out[:14] == "[[<<result>>]]":
+                try:
+                    result = json.loads(out[14:])
+                    _result['result'] = result
+                except json.JSONDecodeError:
+                    if out[14:].strip() != "undefined":
+                        _logger.error("Not supported this behaviour")
+                    _result['result'] = None
+            elif out[:17] == "[[<<exception>>]]":
+                _result['exception'] = out[17:]
+            else:
+                continue
+
+            return _result
+
+    def _close(self):
+        os.remove(self._path)
+        self._node.stdin.close()
+        self._node.stdout.close()
+        self._node.wait()
+
+    def close(self):
+        self._finalizer()
+
+    @property
+    def is_closed(self):
+        if self._finalizer is not None:
+            return not self._finalizer.alive
+
+        return None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __getattr__(self, name):
+        return partial(self.call, name)

pyevaljs4-0.1.0/pyevaljs4/settings.py

@@ -0,0 +1 @@
+ASYNC_CALL_FLAGS = '[[PyEvalJS4_Async_Call]]'

pyevaljs4-0.1.0/pyevaljs4/utils.py

@@ -0,0 +1,8 @@
+import os
+
+
+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

pyevaljs4-0.1.0/pyevaljs4.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.2
+Name: pyevaljs4
+Version: 0.1.0
+Summary: A high-performance Python library that relies on nodejs to execute JavaScript
+Home-page: https://github.com/Smawexi/PyEvalJS4
+Author: Samwe
+Author-email: 1281722462@qq.com
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7.0
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+### A high-performance Python library that relies on nodejs to execute JavaScript
+
+---
+
+### Environments
+
+**Please note that you need to install Node.js and set up the NODE_PATH or NODE environment variable properly!**  
+*If not set, the default will use the Node.js in the system's path.*
+
+---
+
+### Quickstart
+```python
+import pyevaljs4
+
+# example 1
+rt = pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == "xy"
+# Another way of passing parameters
+res = rt.call('f', arg_list=['x', 'y'])
+print(res)
+assert res == "xy"
+# Other equivalent calling methods
+print(rt.f('x',  'y'))
+print(rt.f(arg_list=['x', 'y']))
+# close runtime
+rt.close()
+
+# example 2
+with pyevaljs4.compile_("function f(a,b){console.log(a,b);return a+b;}") as rt:
+    res = rt.call('f', 'x', 'y')
+    print(res)
+    assert res == "xy"
+
+# example 3
+# empty context
+rt = pyevaljs4.compile_()
+# Add the function f to this context
+rt.eval("function f(a,b){console.log(a,b);return a+b;}")
+res = rt.call('f', 'x', 'y')
+print(res)
+assert res == 'xy'
+# Other calling methods
+res = rt.eval("f('x', 'y')")
+print(res)
+assert res == "xy"
+rt.close()
+
+# example 4
+# Call JS asynchronous function
+rt = pyevaljs4.compile_()
+rt.eval("async function f(a,b){console.log(a,b);return a+b;}")
+# To call the JS asynchronous function, you need to pass async_js_func=True
+res = rt.call('f', 'x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+res = rt.f('x', 'y', async_js_func=True)
+print(res)
+assert res == "xy"
+# The shortcut for calling the JS asynchronous function can only be used this way.
+# other cases are not supported.
+res = rt.eval('await f("x", "y")')
+print(res)
+assert res == "xy"
+rt.close()
+```
+---
+
+### Use a custom version of Node.js
+- By setting environment variables to use a custom version of Node, you only need to set the NODE_PATH or NODE environment variables.  
+
+```python
+import os
+# Highest priority
+os.environ['NODE_PATH'] = '/path/to/node.exe'
+
+# Second priority
+os.environ['NODE'] = '/path/to/node.exe'
+```

pyevaljs4-0.1.0/pyevaljs4.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+pyevaljs4/__init__.py
+pyevaljs4/__version__.py
+pyevaljs4/_program.py
+pyevaljs4/exceptions.py
+pyevaljs4/pyevaljs.py
+pyevaljs4/settings.py
+pyevaljs4/utils.py
+pyevaljs4.egg-info/PKG-INFO
+pyevaljs4.egg-info/SOURCES.txt
+pyevaljs4.egg-info/dependency_links.txt
+pyevaljs4.egg-info/top_level.txt

pyevaljs4-0.1.0/pyevaljs4.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyevaljs4-0.1.0/pyevaljs4.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyevaljs4

pyevaljs4-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyevaljs4-0.1.0/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+from pyevaljs4.__version__ import version
+
+
+NAME = 'pyevaljs4'
+URL = "https://github.com/Smawexi/PyEvalJS4"
+EMAIL = '1281722462@qq.com'
+AUTHOR = 'Samwe'
+REQUIRES_PYTHON = '>=3.7.0'
+DESCRIPTION = 'A high-performance Python library that relies on nodejs to execute JavaScript'
+LONG_DESCRIPTION = open('README.md', encoding="utf-8").read()
+
+setup(
+    name=NAME,
+    version=version,
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=EMAIL,
+    url=URL,
+    packages=find_packages(where=".", exclude=('tests',)),
+    classifiers=[
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'License :: OSI Approved :: MIT License'
+    ],
+    python_requires=REQUIRES_PYTHON
+)