Create app.py

app.py

@@ -0,0 +1,592 @@
+import ast
+import io
+import sys
+import subprocess
+import tempfile
+import gradio as gr
+import shutil
+from contextlib import redirect_stdout
+
+# =============================================================================
+# Python To JavaScript 轉換器
+# =============================================================================
+
+class PythonToJavaScriptConverter(ast.NodeVisitor):
+    def __init__(self):
+        self.variables = set()  # 用於追蹤已聲明的變量
+        self.current_scope = []
+        self.indent_level = 0
+
+    def indent(self):
+        return '    ' * self.indent_level
+
+    def visit_FunctionDef(self, node):
+        self.current_scope.append(node.name)
+        func_name = node.name
+        args = [arg.arg for arg in node.args.args]
+        defaults = [self.visit(d) for d in node.args.defaults]
+        args_list = []
+        num_args = len(args)
+        num_defaults = len(defaults)
+        for i, arg in enumerate(args):
+            if i >= num_args - num_defaults:
+                default = defaults[i - (num_args - num_defaults)]
+                args_list.append(f"{arg} = {default}")
+            else:
+                args_list.append(arg)
+        args_str = ", ".join(args_list)
+        self.indent_level += 1
+        body = "\n".join(self.visit(n) for n in node.body)
+        self.indent_level -= 1
+        self.current_scope.pop()
+        return f"{self.indent()}function {func_name}({args_str}) {{\n{body}\n{self.indent()}}}"
+
+    def visit_Return(self, node):
+        if node.value:
+            return f"{self.indent()}return {self.visit(node.value)};"
+        else:
+            return f"{self.indent()}return;"
+
+    def visit_Assign(self, node):
+        target = node.targets[0]
+        value = self.visit(node.value)
+        if isinstance(target, ast.Tuple):
+            targets = [self.visit(t) for t in target.elts]
+            if not isinstance(node.value, ast.Tuple):
+                value = f"[{value}]"
+            assignment = f"{self.indent()}let [{', '.join(targets)}] = {value};"
+        else:
+            target_str = self.visit(target)
+            if target_str not in self.variables:
+                declaration = "let "
+                self.variables.add(target_str)
+            else:
+                declaration = ""
+            assignment = f"{self.indent()}{declaration}{target_str} = {value};"
+        return assignment
+
+    def visit_If(self, node):
+        test = self.visit(node.test)
+        self.indent_level += 1
+        if_body = "\n".join(self.visit(n) for n in node.body)
+        self.indent_level -= 1
+        if node.orelse:
+            self.indent_level += 1
+            else_body = "\n".join(self.visit(n) for n in node.orelse)
+            self.indent_level -= 1
+            return f"{self.indent()}if (({test})) {{\n{if_body}\n{self.indent()}}} else {{\n{else_body}\n{self.indent()}}}"
+        else:
+            return f"{self.indent()}if (({test})) {{\n{if_body}\n{self.indent()}}}"
+
+    def visit_While(self, node):
+        test = self.visit(node.test)
+        self.indent_level += 1
+        body = "\n".join(self.visit(n) for n in node.body)
+        self.indent_level -= 1
+        return f"{self.indent()}while ({test}) {{\n{body}\n{self.indent()}}}"
+
+    def visit_For(self, node):
+        target = self.visit(node.target)
+        if isinstance(node.iter, ast.Call) and isinstance(node.iter.func, ast.Name) and node.iter.func.id == "range":
+            args = [self.visit(arg) for arg in node.iter.args]
+            if len(args) == 1:
+                iterable = f"Array.from({{length: {args[0]}}}, (_, {target}) => {target})"
+            elif len(args) == 2:
+                iterable = f"Array.from({{length: {args[1]} - {args[0]}}}, (_, {target}) => {target} + {args[0]})"
+            else:
+                iterable = f"Array.from({{length: 1}}, (_, {target}) => {target})"
+        else:
+            iterable = self.visit(node.iter)
+        self.indent_level += 1
+        body = "\n".join(self.visit(n) for n in node.body)
+        self.indent_level -= 1
+        return f"{self.indent()}for (let {target} of {iterable}) {{\n{body}\n{self.indent()}}}"
+
+    def visit_Try(self, node):
+        try_body = "\n".join(self.visit(n) for n in node.body)
+        catch_body = ""
+        if node.handlers:
+            handler_lines = []
+            for handler in node.handlers:
+                if handler.type:
+                    type_str = self.visit(handler.type)
+                    handler_body = "\n".join(self.visit(n) for n in handler.body)
+                    clause = f"if (e instanceof {type_str}) {{\n{self.indent()}    {handler_body}\n{self.indent()}}}"
+                    handler_lines.append(clause)
+                else:
+                    handler_body = "\n".join(self.visit(n) for n in handler.body)
+                    handler_lines.append(f"{{\n{self.indent()}    {handler_body}\n{self.indent()}}}")
+            catch_body = ("\n" + self.indent() + "else ").join(handler_lines)
+        else:
+            catch_body = f"{self.indent()}/* No exception handlers */"
+        finally_body = ""
+        if node.finalbody:
+            self.indent_level += 1
+            finally_body = "\n".join(self.visit(n) for n in node.finalbody)
+            self.indent_level -= 1
+            finally_body = f"\n{self.indent()}finally {{\n{finally_body}\n{self.indent()}}}"
+        return f"{self.indent()}try {{\n{try_body}\n{self.indent()}}} catch(e) {{\n{self.indent()}    {catch_body}\n{self.indent()}}}{finally_body}"
+
+    def visit_With(self, node):
+        items = []
+        for item in node.items:
+            context_expr = self.visit(item.context_expr)
+            optional_vars = self.visit(item.optional_vars) if item.optional_vars else ""
+            items.append(f"{context_expr} as {optional_vars}" if optional_vars else context_expr)
+        with_comment = f"// with: {', '.join(items)}"
+        self.indent_level += 1
+        body = "\n".join(self.visit(n) for n in node.body)
+        self.indent_level -= 1
+        return f"{self.indent()}{with_comment}\n{body}"
+
+    def visit_Call(self, node):
+        func_name = ""
+        if isinstance(node.func, ast.Name):
+            func_name = node.func.id
+        if func_name == "print":
+            func = "console.log"
+        elif func_name == "range":
+            return self.handle_range(node)
+        elif func_name == "list":
+            arg = self.visit(node.args[0])
+            return f"Array.from({arg})"
+        else:
+            func = self.visit(node.func)
+        args = ", ".join(self.visit(arg) for arg in node.args)
+        return f"{func}({args})"
+
+    def handle_range(self, node):
+        args = [self.visit(arg) for arg in node.args]
+        if len(node.args) == 1:
+            return f"Array.from({{length: {args[0]}}}, (_, i) => i)"
+        elif len(node.args) == 2:
+            return f"Array.from({{length: {args[1]} - {args[0]}}}, (_, i) => i + {args[0]})"
+        return f"Array.from({{length: 1}})"
+
+    def visit_ListComp(self, node):
+        if len(node.generators) > 1:
+            return "/* Unsupported list comprehension with multiple generators */"
+        gen = node.generators[0]
+        target = self.visit(gen.target)
+        if_condition = None
+        if gen.ifs:
+            conditions = " && ".join(self.visit(cond) for cond in gen.ifs)
+            if_condition = conditions
+        iter_expr = gen.iter
+        if isinstance(iter_expr, ast.Call) and isinstance(iter_expr.func, ast.Name) and iter_expr.func.id == "range":
+            args = [self.visit(arg) for arg in iter_expr.args]
+            if len(iter_expr.args) == 1:
+                range_str = f"Array.from({{length: {args[0]}}}, (_, {target}) => {target})"
+            elif len(iter_expr.args) == 2:
+                range_str = f"Array.from({{length: {args[1]} - {args[0]}}}, (_, {target}) => {target} + {args[0]})"
+            else:
+                range_str = f"Array.from({{length: 1}}, (_, {target}) => {target})"
+        else:
+            range_str = self.visit(iter_expr)
+        elt = self.visit(node.elt)
+        if if_condition:
+            return f"{range_str}.filter(({target}) => {if_condition}).map(({target}) => ({elt}))"
+        else:
+            return f"{range_str}.map(({target}) => ({elt}))"
+
+    def visit_GeneratorExp(self, node):
+        if len(node.generators) > 1:
+            return "/* Unsupported generator expression with multiple generators */"
+        gen = node.generators[0]
+        target = self.visit(gen.target)
+        if_condition = None
+        if gen.ifs:
+            conditions = " && ".join(self.visit(cond) for cond in gen.ifs)
+            if_condition = conditions
+        iter_expr = gen.iter
+        if isinstance(iter_expr, ast.Call) and isinstance(iter_expr.func, ast.Name) and iter_expr.func.id == "range":
+            args = [self.visit(arg) for arg in iter_expr.args]
+            if len(iter_expr.args) == 1:
+                range_str = f"Array.from({{length: {args[0]}}}, (_, {target}) => {target})"
+            elif len(iter_expr.args) == 2:
+                range_str = f"Array.from({{length: {args[1]} - {args[0]}}}, (_, {target}) => {target} + {args[0]})"
+            else:
+                range_str = f"Array.from({{length: 1}}, (_, {target}) => {target})"
+        else:
+            range_str = self.visit(iter_expr)
+        elt = self.visit(node.elt)
+        if if_condition:
+            gen_body = (
+                f"for (let {target} of {range_str}) {{\n"
+                f"    if (!({if_condition})) continue;\n"
+                f"    yield ({elt});\n"
+                f"}}"
+            )
+        else:
+            gen_body = (
+                f"for (let {target} of {range_str}) {{\n"
+                f"    yield ({elt});\n"
+                f"}}"
+            )
+        return f"(function* () {{\n{gen_body}\n}})()"
+
+    def visit_BinOp(self, node):
+        if isinstance(node.op, ast.FloorDiv):
+            left = self.visit(node.left)
+            right = self.visit(node.right)
+            return f"Math.floor({left} / {right})"
+        elif isinstance(node.op, ast.Pow):
+            left = self.visit(node.left)
+            right = self.visit(node.right)
+            return f"Math.pow({left}, {right})"
+        else:
+            left = self.visit(node.left)
+            op = self.visit(node.op)
+            right = self.visit(node.right)
+            return f"{left} {op} {right}"
+
+    def visit_Compare(self, node):
+        if len(node.ops) != 1 or len(node.comparators) != 1:
+            return "/* Unsupported comparison */"
+        left = self.visit(node.left)
+        op = self.visit(node.ops[0])
+        comparator = self.visit(node.comparators[0])
+        return f"{left} {op} {comparator}"
+
+    def visit_BoolOp(self, node):
+        if isinstance(node.op, ast.And):
+            op = "&&"
+        elif isinstance(node.op, ast.Or):
+            op = "||"
+        else:
+            op = "/* Unsupported BoolOp */"
+        values = [self.visit(v) for v in node.values]
+        return f"{f' {op} '.join(values)}"
+
+    def visit_UnaryOp(self, node):
+        if isinstance(node.op, ast.Not):
+            op = "!"
+        else:
+            op = "/* Unsupported UnaryOp */"
+        operand = self.visit(node.operand)
+        return f"{op}{operand}"
+
+    def visit_Attribute(self, node):
+        obj = self.visit(node.value)
+        return f"{obj}.{node.attr}"
+
+    def visit_Subscript(self, node):
+        value = self.visit(node.value)
+        index = self.visit(node.slice)
+        return f"{value}[{index}]"
+
+    def visit_Index(self, node):
+        return self.visit(node.value)
+
+    def visit_Name(self, node):
+        return node.id
+
+    def visit_Constant(self, node):
+        if node.value is None:
+            return "null"
+        elif isinstance(node.value, bool):
+            return "true" if node.value else "false"
+        elif isinstance(node.value, str):
+            return f'"{node.value}"'
+        return str(node.value)
+
+    def visit_List(self, node):
+        elements = [self.visit(e) for e in node.elts]
+        return f"[{', '.join(elements)}]"
+
+    def visit_Tuple(self, node):
+        elements = [self.visit(e) for e in node.elts]
+        return f"[{', '.join(elements)}]"
+
+    def visit_Dict(self, node):
+        pairs = []
+        for k, v in zip(node.keys, node.values):
+            key = self.visit(k) if k else ""
+            value = self.visit(v)
+            if isinstance(k, ast.Constant) and isinstance(k.value, str):
+                key = f'"{k.value}"'
+            pairs.append(f"{key}: {value}")
+        return f"{{{', '.join(pairs)}}}"
+
+    def visit_Expr(self, node):
+        expr = self.visit(node.value)
+        return f"{self.indent()}{expr};"
+
+    def visit_AugAssign(self, node):
+        target = self.visit(node.target)
+        op = self.visit(node.op)
+        value = self.visit(node.value)
+        return f"{self.indent()}{target} {op}= {value};"
+
+    def visit_Add(self, node):
+        return "+"
+
+    def visit_Sub(self, node):
+        return "-"
+
+    def visit_Mult(self, node):
+        return "*"
+
+    def visit_Div(self, node):
+        return "/"
+
+    def visit_Mod(self, node):
+        return "%"
+
+    def visit_Eq(self, node):
+        return "==="
+
+    def visit_NotEq(self, node):
+        return "!=="
+
+    def visit_Lt(self, node):
+        return "<"
+
+    def visit_LtE(self, node):
+        return "<="
+
+    def visit_Gt(self, node):
+        return ">"
+
+    def visit_GtE(self, node):
+        return ">="
+
+    def visit_ClassDef(self, node):
+        class_name = node.name
+        methods = []
+        for n in node.body:
+            if isinstance(n, ast.FunctionDef):
+                if n.name == "__init__":
+                    method_code = self.visit_FunctionDef(n)
+                    method_code = method_code.replace("function __init__", "constructor")
+                    methods.append(method_code)
+                else:
+                    methods.append(self.visit_FunctionDef(n))
+            else:
+                methods.append(self.visit(n))
+        body_str = "\n".join(methods)
+        return f"{self.indent()}class {class_name} {{\n{body_str}\n{self.indent()}}}"
+
+    def generic_visit(self, node):
+        return f"/* Unhandled node type: {type(node).__name__} */"
+
+def convert_python_to_javascript(python_code):
+    tree = ast.parse(python_code)
+    converter = PythonToJavaScriptConverter()
+    return "\n".join(filter(None, (converter.visit(n) for n in tree.body)))
+
+# =============================================================================
+# 執行 Python 程式碼，並捕捉其輸出
+# =============================================================================
+def run_python_code(code):
+    stdout = io.StringIO()
+    try:
+        with redirect_stdout(stdout):
+            exec(code, {})
+    except Exception as e:
+        stdout.write(f"Error: {str(e)}")
+    return stdout.getvalue()
+
+# =============================================================================
+# 執行 JavaScript 程式碼（需要系統有 node.js 環境）
+# =============================================================================
+def run_js_code(js_code):
+    if not shutil.which("node"):
+        return "Error: Node.js is not installed or not available in the system PATH."
+    try:
+        with tempfile.NamedTemporaryFile("w", suffix=".js", delete=False) as temp_js:
+            temp_js.write(js_code)
+            temp_js.flush()
+            temp_js_name = temp_js.name
+        result = subprocess.run(["node", temp_js_name],
+                                capture_output=True, text=True, timeout=5)
+        output = result.stdout
+        if result.stderr:
+            output += "\nError:\n" + result.stderr
+    except Exception as e:
+        output = f"Error executing JS code: {str(e)}"
+    return output
+
+# =============================================================================
+# 定義多組範例測試代碼 (覆蓋所有測試情況)
+# =============================================================================
+sample_dict = {
+    "Simple Function": '''\
+def add(a, b):
+    return a + b
+print(add(2, 3))
+''',
+
+    "If/Else": '''\
+def max_num(a, b):
+    if a > b:
+        return a
+    else:
+        return b
+print(max_num(10, 20))
+''',
+
+    "While Loop": '''\
+i = 0
+while i < 5:
+    print(i)
+    i += 1
+''',
+
+    "For Loop": '''\
+for x in range(3):
+    print(x)
+''',
+
+    "List Comprehension (without if)": '''\
+numbers = [x * 2 for x in range(5)]
+print(numbers)
+''',
+
+    "List Comprehension (with if)": '''\
+numbers = [x for x in range(10) if x % 2 == 0]
+print(numbers)
+''',
+
+    "Dictionary Access": '''\
+person = {"name": "Alice", "age": 30}
+print(person["name"])
+''',
+
+    "Augmented Assignment": '''\
+count = 10
+count += 5
+print(count)
+''',
+
+    "Multiple Assignments": '''\
+a, b = 1, 2
+print(a)
+print(b)
+''',
+
+    "Boolean Operations": '''\
+a = True
+b = False
+if a and not b:
+    print("Both conditions met")
+''',
+
+    "Nested Functions": '''\
+def outer(x):
+    def inner(y):
+        return y * 2
+    return inner(x) + 1
+print(outer(5))
+''',
+
+    "None and Boolean": '''\
+result = None
+flag = True
+if flag:
+    result = "Success"
+else:
+    result = "Failure"
+print(result)
+''',
+
+    "Floor Div and Pow": '''\
+a = 5 // 2
+b = 2 ** 3
+print(a)
+print(b)
+''',
+
+    "Class Definition": '''\
+class Person:
+    def __init__(self, name):
+        self.name = name
+    def greet(self):
+        print("Hello, " + self.name)
+p = Person("Alice")
+p.greet()
+''',
+
+    "Default Parameter": '''\
+def greet(name="World"):
+    print("Hello, " + name)
+greet()
+''',
+
+    "Nested If/Else": '''\
+if a > b:
+    if b > c:
+        print("a > b > c")
+else:
+    print("Not in order")
+''',
+
+    "Nested For Loops": '''\
+for i in range(3):
+    for j in range(2):
+        print(i, j)
+''',
+
+    "Generator Expression": '''\
+gen = (x * 2 for x in range(5))
+print(list(gen))
+'''
+}
+
+sample_choices = list(sample_dict.keys())
+
+def load_sample(sample_name):
+    return sample_dict.get(sample_name, "")
+
+# =============================================================================
+# Gradio 介面主函數
+# =============================================================================
+def process_code(python_code):
+    try:
+        tree = ast.parse(python_code)
+        ast_tree = ast.dump(tree, indent=4)
+    except Exception as e:
+        ast_tree = f"AST Error: {e}"
+    python_output = run_python_code(python_code)
+    try:
+        js_code = convert_python_to_javascript(python_code)
+    except Exception as e:
+        js_code = f"Conversion Error: {e}"
+    js_output = run_js_code(js_code)
+    return ast_tree, python_output, js_code, js_output
+
+# =============================================================================
+# 建立 Gradio 介面，包含下拉選單、Code 輸入與多個輸出區塊
+# =============================================================================
+with gr.Blocks(css="#component-7 {font-family: 'Consolas', monospace;}") as demo:
+    gr.Markdown("# Python ↔ JavaScript 互動轉換器")
+    gr.Markdown("請從下拉選單中選取範例程式碼或直接貼上 Python 程式碼，即可看到其 AST、執行結果，以及轉換後的 JavaScript 程式碼與執行結果。")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            sample_dropdown = gr.Dropdown(label="Select a Sample", choices=sample_choices, value=sample_choices[0])
+        with gr.Column(scale=3):
+            python_code_input = gr.Code(
+                label="Python Code Input", 
+                language="python",
+                value=sample_dict[sample_choices[0]],
+                interactive=True)
+    
+    sample_dropdown.change(fn=load_sample, inputs=sample_dropdown, outputs=python_code_input)
+
+    run_button = gr.Button("Run Code")
+    
+    with gr.Row():
+        with gr.Column():
+            ast_output = gr.Code(label="AST Tree", language="python", interactive=False)
+            python_exec_output = gr.Textbox(label="Python Execution Output", interactive=False)
+        with gr.Column():
+            js_code_output = gr.Code(label="Converted JavaScript Code", language="javascript", interactive=False)
+            js_exec_output = gr.Textbox(label="JavaScript Execution Output", interactive=False)
+    
+    run_button.click(fn=process_code,
+                     inputs=python_code_input,
+                     outputs=[ast_output, python_exec_output, js_code_output, js_exec_output])
+
+if __name__ == "__main__":
+    demo.launch()