Update app.py

app.py

@@ -1,179 +1,97 @@
 import gradio as gr
-import subprocess
-import tempfile
+import sys
+import io
+import contextlib
 import ast
-import textwrap
 import os
-import json
-import logging
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# ----------------- Helper Functions -----------------
+import shutil
+import tempfile
 
-def wrap_last_expr_with_return(code: str) -> str:
-    """Nếu dòng cuối là expression, tự động chuyển thành return."""
+def run(code):
+    if not code.strip():
+        return "No code provided", ""
     try:
-        tree = ast.parse(code)
-        if tree.body and isinstance(tree.body[-1], ast.Expr):
-            tree.body[-1] = ast.Return(value=tree.body[-1].value)
-            return ast.unparse(tree)
+        ast.parse(code)
     except Exception as e:
-        logger.warning(f"AST transform failed: {e}")
-    return code
-
-def wrap_code_for_execution(user_code: str) -> str:
-    """Tạo wrapper code để bắt stdout/stderr và đánh dấu return_value."""
-    indented_code = textwrap.indent(user_code, "    ")
-    template = f'''import sys
-import json
-from io import StringIO
-import contextlib
-
-@contextlib.contextmanager
-def capture_output():
-    stdout, stderr = StringIO(), StringIO()
-    old_out, old_err = sys.stdout, sys.stderr
-    try:
-        sys.stdout, sys.stderr = stdout, stderr
-        yield stdout, stderr
-    finally:
-        sys.stdout, sys.stderr = old_out, old_err
-
-def execute_code():
-{indented_code}
-
-with capture_output() as (stdout, stderr):
+        return str(e), ""
+    
+    temp_dir = None
     try:
-        result_value = execute_code()
+        temp_dir = tempfile.mkdtemp()
+        sys.path.insert(0, temp_dir)
+        
+        @contextlib.contextmanager
+        def capture_output():
+            stdout, stderr = io.StringIO(), io.StringIO()
+            old_out, old_err = sys.stdout, sys.stderr
+            try:
+                sys.stdout, sys.stderr = stdout, stderr
+                yield stdout, stderr
+            finally:
+                sys.stdout, sys.stderr = old_out, old_err
+        
+        with capture_output() as (stdout, stderr):
+            try:
+                globals_dict = {}
+                locals_dict = {}
+                
+                code_lines = code.strip().split('\n')
+                
+                if len(code_lines) > 1:
+                    exec('\n'.join(code_lines[:-1]), globals_dict, locals_dict)
+                
+                last_line = code_lines[-1].strip()
+                result_value = None
+                
+                if last_line:
+                    try:
+                        compile(last_line, '<string>', 'eval')
+                        result_value = eval(last_line, globals_dict, locals_dict)
+                    except SyntaxError:
+                        exec(last_line, globals_dict, locals_dict)
+                
+            except Exception as e:
+                print(str(e), file=sys.stderr)
+                result_value = None
+        
+        combined_output = stdout.getvalue() + stderr.getvalue()
+        return_value = str(result_value) if result_value is not None else ""
+        
+        return combined_output, return_value
+        
     except Exception as e:
-        import traceback
-        print("Error:", traceback.format_exc(), file=sys.stderr)
-        result_value = None
-
-# In log stdout/stderr sau khi chạy xong
-log_text = stdout.getvalue() + stderr.getvalue()
-print(log_text, end="")
-
-# Đánh dấu return_value riêng
-print("__RETURN_VALUE__:" + json.dumps(result_value))
-'''
-    return template
-
-# ----------------- Executor -----------------
-
-def execute_code_input(code, attached_files, state_process: gr.State):
-    """Chạy code input + file đính kèm, trả log và return riêng, không stream"""
-    code = wrap_last_expr_with_return(code)
-    final_code = wrap_code_for_execution(code)
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Lưu file đính kèm
-        if attached_files is not None:
-            for file in attached_files:
-                dest = os.path.join(temp_dir, os.path.basename(file.name))
-                with open(dest, "wb") as f:
-                    f.write(file.read())
-
-        # Ghi file code
-        script_path = os.path.join(temp_dir, "main.py")
-        with open(script_path, "w") as f:
-            f.write(final_code)
-
-        logger.debug(f"Generated code:\n{final_code}")
-
-        # Chạy subprocess unbuffered (-u)
-        process = subprocess.Popen(
-            ["python3", "-u", script_path],
-            cwd=temp_dir,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-        )
-
-        state_process.value = process  # Lưu process vào state để cancel
-
-        # Chờ chạy xong
-        stdout, _ = process.communicate()
-        state_process.value = None
-
-        log_text = []
-        return_value = None
-        for line in stdout.splitlines():
-            if line.startswith("__RETURN_VALUE__:"):
-                try:
-                    return_value = json.loads(line.replace("__RETURN_VALUE__:", "", 1))
-                except Exception:
-                    return_value = None
-            else:
-                log_text.append(line)
-
-        return "\n".join(log_text), str(return_value) if return_value is not None else ""
-
-def cancel_code(state_process: gr.State):
-    process = state_process.value
-    if process and process.poll() is None:
-        process.terminate()
-        state_process.value = None
-        return "Execution Cancelled"
-    return "No running process"
-
-# ----------------- Gradio UI -----------------
-
-code_examples = [
-    "1 + 1",
-    "a = 5\na",
-    "print('Hello')\n3 * 3",
-    "for i in range(3):\n    print(i)",
-    "from time import sleep\nfor i in [1,2,3]:\n    sleep(1)\n    print(i)"
-]
-
-with gr.Blocks(theme=gr.themes.Default(primary_hue="red")) as demo:
-    gr.Markdown("# 🔴 Python Executor (Log + Return Value Separate + Cancel)")
-
-    state_process = gr.State(None)  # Lưu subprocess để cancel
+        return str(e), ""
+    finally:
+        if temp_dir is not None:
+            try:
+                sys.path.remove(temp_dir)
+            except ValueError:
+                pass
+            try:
+                shutil.rmtree(temp_dir)
+            except:
+                pass
+
+with gr.Blocks(title="Python Code Executor") as demo:
+    gr.Markdown("# 🔧 Python Code Executor")
+    gr.Markdown("Enter your Python code below or upload files, then click **Run** to execute it.")
 
     with gr.Row():
         with gr.Column():
-            code_input = gr.Code(
-                label="Python Code",
-                language="python",
-                interactive=True
-            )
-
-            attached_files = gr.File(
-                label="📎 Attach Files (optional)",
-                file_types=[".txt", ".csv", ".json", ".py", ".md", ".xml", ".yaml", ".yml"],
-                file_count="multiple"
-            )
-
-            run_code_btn = gr.Button("▶️ Run Code")
-            cancel_btn = gr.Button("⏹ Cancel")
-
-            gr.Markdown("### 📝 Examples:")
-            examples_component = gr.Examples(
-                examples=[[ex] for ex in code_examples],  # ép dọc
-                inputs=[code_input],
-                label=None,
-                examples_per_page=10,
-            )
+            code_input = gr.Code(label="Python Code", language="python", lines=15)
+            output_display = gr.Textbox(label="Log", interactive=False)
+            return_value_display = gr.Textbox(label="Return", interactive=False)
+  
 
         with gr.Column():
-            log_box = gr.Textbox(label="Execution Log", lines=15)
-            return_box = gr.Textbox(label="Return Value", lines=1)
-
-    run_code_btn.click(
-        execute_code_input,
-        [code_input, attached_files, state_process],
-        [log_box, return_box],
-    )
-
-    cancel_btn.click(
-        cancel_code,
-        [state_process],
-        [log_box]
+            file_upload = gr.File(label="Upload Files (txt, csv, images, etc.)", file_types=None, file_count="multiple")
+            run_button = gr.Button("▶ Run Code", variant="primary")
+    
+    run_button.click(
+        fn=execute_python_code,
+        inputs=[code_input, file_upload],
+        outputs=[output_display, return_value_display]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()