improve: exract Code Node provider for each supported scripting language (#4164)

api/core/helper/code_executor/code_executor.py

@@ -10,9 +10,10 @@ from yarl import URL
 
 from config import get_env
 from core.helper.code_executor.entities import CodeDependency
-from core.helper.code_executor.javascript_transformer import NodeJsTemplateTransformer
-from core.helper.code_executor.jinja2_transformer import Jinja2TemplateTransformer
-from core.helper.code_executor.python_transformer import PYTHON_STANDARD_PACKAGES, PythonTemplateTransformer
+from core.helper.code_executor.javascript.javascript_transformer import NodeJsTemplateTransformer
+from core.helper.code_executor.jinja2.jinja2_transformer import Jinja2TemplateTransformer
+from core.helper.code_executor.python3.python3_transformer import PYTHON_STANDARD_PACKAGES, Python3TemplateTransformer
+from core.helper.code_executor.template_transformer import TemplateTransformer
 
 logger = logging.getLogger(__name__)
 
@@ -34,6 +35,7 @@ class CodeExecutionResponse(BaseModel):
     message: str
     data: Data
 
+
 class CodeLanguage(str, Enum):
     PYTHON3 = 'python3'
     JINJA2 = 'jinja2'
@@ -44,8 +46,8 @@ class CodeExecutor:
     dependencies_cache = {}
     dependencies_cache_lock = Lock()
 
-    code_template_transformers = {
-        CodeLanguage.PYTHON3: PythonTemplateTransformer,
+    code_template_transformers: dict[CodeLanguage, type[TemplateTransformer]] = {
+        CodeLanguage.PYTHON3: Python3TemplateTransformer,
         CodeLanguage.JINJA2: Jinja2TemplateTransformer,
         CodeLanguage.JAVASCRIPT: NodeJsTemplateTransformer,
     }
@@ -56,6 +58,10 @@ class CodeExecutor:
         CodeLanguage.PYTHON3: CodeLanguage.PYTHON3,
     }
 
+    supported_dependencies_languages: set[CodeLanguage] = {
+        CodeLanguage.PYTHON3
+    }
+
     @classmethod
     def execute_code(cls, 
                      language: Literal['python3', 'javascript', 'jinja2'], 
@@ -133,7 +139,10 @@ class CodeExecutor:
         return template_transformer.transform_response(response)
     
     @classmethod
-    def list_dependencies(cls, language: Literal['python3']) -> list[CodeDependency]:
+    def list_dependencies(cls, language: str) -> list[CodeDependency]:
+        if language not in cls.supported_dependencies_languages:
+            return []
+
         with cls.dependencies_cache_lock:
             if language in cls.dependencies_cache:
                 # check expiration

api/core/helper/code_executor/code_node_provider.py

@@ -0,0 +1,55 @@
+from abc import abstractmethod
+
+from pydantic import BaseModel
+
+from core.helper.code_executor.code_executor import CodeExecutor
+
+
+class CodeNodeProvider(BaseModel):
+    @staticmethod
+    @abstractmethod
+    def get_language() -> str:
+        pass
+
+    @classmethod
+    def is_accept_language(cls, language: str) -> bool:
+        return language == cls.get_language()
+
+    @classmethod
+    @abstractmethod
+    def get_default_code(cls) -> str:
+        """
+        get default code in specific programming language for the code node
+        """
+        pass
+
+    @classmethod
+    def get_default_available_packages(cls) -> list[dict]:
+        return [p.dict() for p in CodeExecutor.list_dependencies(cls.get_language())]
+
+    @classmethod
+    def get_default_config(cls) -> dict:
+        return {
+            "type": "code",
+            "config": {
+                "variables": [
+                    {
+                        "variable": "arg1",
+                        "value_selector": []
+                    },
+                    {
+                        "variable": "arg2",
+                        "value_selector": []
+                    }
+                ],
+                "code_language": cls.get_language(),
+                "code": cls.get_default_code(),
+                "outputs": {
+                    "result": {
+                        "type": "string",
+                        "children": None
+                    }
+                }
+            },
+            "available_dependencies": cls.get_default_available_packages(),
+        }

api/core/helper/code_executor/entities.py

@@ -3,4 +3,4 @@ from pydantic import BaseModel
 
 class CodeDependency(BaseModel):
     name: str
-    version: str
+    version: str

api/core/helper/code_executor/javascript/javascript_code_provider.py

@@ -0,0 +1,21 @@
+from textwrap import dedent
+
+from core.helper.code_executor.code_executor import CodeLanguage
+from core.helper.code_executor.code_node_provider import CodeNodeProvider
+
+
+class JavascriptCodeProvider(CodeNodeProvider):
+    @staticmethod
+    def get_language() -> str:
+        return CodeLanguage.JAVASCRIPT
+
+    @classmethod
+    def get_default_code(cls) -> str:
+        return dedent(
+            """
+            function main({arg1, arg2}) {
+                return {
+                    result: arg1 + arg2
+                }
+            }
+            """)

api/core/helper/code_executor/javascript/javascript_transformer.py

@@ -22,6 +22,7 @@ console.log(result)
 
 NODEJS_PRELOAD = """"""
 
+
 class NodeJsTemplateTransformer(TemplateTransformer):
     @classmethod
     def transform_caller(cls, code: str, inputs: dict, 

api/core/helper/code_executor/jinja2/jinja2_formatter.py

@@ -1,4 +1,4 @@
-from core.helper.code_executor.code_executor import CodeExecutor
+from core.helper.code_executor.code_executor import CodeExecutor, CodeLanguage
 
 
 class Jinja2Formatter:
@@ -11,7 +11,7 @@ class Jinja2Formatter:
         :return:
         """
         result = CodeExecutor.execute_workflow_code_template(
-            language='jinja2', code=template, inputs=inputs
+            language=CodeLanguage.JINJA2, code=template, inputs=inputs
         )
 
-        return result['result']
+        return result['result']

api/core/helper/code_executor/jinja2/jinja2_transformer.py

@@ -4,7 +4,7 @@ from base64 import b64encode
 from typing import Optional
 
 from core.helper.code_executor.entities import CodeDependency
-from core.helper.code_executor.python_transformer import PYTHON_STANDARD_PACKAGES
+from core.helper.code_executor.python3.python3_transformer import PYTHON_STANDARD_PACKAGES
 from core.helper.code_executor.template_transformer import TemplateTransformer
 
 PYTHON_RUNNER = """

api/core/helper/code_executor/python3/python3_code_provider.py

@@ -0,0 +1,20 @@
+from textwrap import dedent
+
+from core.helper.code_executor.code_executor import CodeLanguage
+from core.helper.code_executor.code_node_provider import CodeNodeProvider
+
+
+class Python3CodeProvider(CodeNodeProvider):
+    @staticmethod
+    def get_language() -> str:
+        return CodeLanguage.PYTHON3
+
+    @classmethod
+    def get_default_code(cls) -> str:
+        return dedent(
+            """
+            def main(arg1: int, arg2: int) -> dict:
+                return {
+                    "result": arg1 + arg2,
+                }
+            """)

api/core/helper/code_executor/python3/python3_transformer.py

@@ -1,12 +1,14 @@
 import json
 import re
 from base64 import b64encode
+from textwrap import dedent
 from typing import Optional
 
 from core.helper.code_executor.entities import CodeDependency
 from core.helper.code_executor.template_transformer import TemplateTransformer
 
-PYTHON_RUNNER = """# declare main function here
+PYTHON_RUNNER = dedent("""
+# declare main function here
 {{code}}
 
 from json import loads, dumps
@@ -25,16 +27,17 @@ result = f'''<<RESULT>>
 <<RESULT>>'''
 
 print(result)
-"""
+""")
 
 PYTHON_PRELOAD = """"""
 
-PYTHON_STANDARD_PACKAGES = set([
+PYTHON_STANDARD_PACKAGES = {
     'json', 'datetime', 'math', 'random', 're', 'string', 'sys', 'time', 'traceback', 'uuid', 'os', 'base64',
-    'hashlib', 'hmac', 'binascii', 'collections', 'functools', 'operator', 'itertools', 'uuid', 
-])
+    'hashlib', 'hmac', 'binascii', 'collections', 'functools', 'operator', 'itertools', 'uuid',
+}
 
-class PythonTemplateTransformer(TemplateTransformer):
+
+class Python3TemplateTransformer(TemplateTransformer):
     @classmethod
     def transform_caller(cls, code: str, inputs: dict, 
                          dependencies: Optional[list[CodeDependency]] = None) -> tuple[str, str, list[CodeDependency]]: