Update app.py

app.py

@@ -1,34 +1,39 @@
 import gradio as gr
 import subprocess
 import tempfile
-import json
+import ast
 import textwrap
 import os
-import ast
-import zipfile
+import json
 import logging
 
-# Setup logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-def execute_code_input(code, attached_files):
-    """Chạy code nhập trực tiếp với file đính kèm - mỗi lần chạy trong session độc lập"""
+# ----------------- Helper Functions -----------------
 
-    # Kiểm tra cú pháp
+def wrap_last_expr_with_return(code: str) -> str:
+    """
+    Nếu dòng cuối là expression, tự động chuyển thành return.
+    """
     try:
-        ast.parse(code)
-    except SyntaxError as e:
-        return f"SyntaxError: {e.msg}\nLine {e.lineno}: {e.text or ''}", ""
-
-    # Indent code
-    indented_code = textwrap.indent(code, '    ')
-
-    template = '''import sys
+        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)
+    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
-import ast
 
 @contextlib.contextmanager
 def capture_output():
@@ -41,225 +46,121 @@ def capture_output():
         sys.stdout, sys.stderr = old_out, old_err
 
 def execute_code():
-{}
-    return None
+{indented_code}
 
 with capture_output() as (stdout, stderr):
     try:
-        import traceback
-        # Thực thi code người dùng
         result_value = execute_code()
-
-        # Nếu không có return thì thử lấy expression cuối cùng
-        if result_value is None:
-            try:
-                tree = ast.parse("""{}""")
-                if tree.body and isinstance(tree.body[-1], ast.Expr):
-                    last_expr = compile(ast.Expression(tree.body[-1].value), "<ast>", "eval")
-                    result_value = eval(last_expr, globals(), locals())
-            except Exception:
-                pass
-
     except Exception as e:
+        import traceback
         print("Error:", traceback.format_exc(), file=sys.stderr)
         result_value = None
 
-result = {{
-    'stdout': stdout.getvalue(),
-    'stderr': stderr.getvalue(),
-    'return_value': result_value
-}}
-print(json.dumps(result))
-'''.format(indented_code, code)
-
-    final_code = template
+# In log stdout/stderr
+if stdout.getvalue():
+    print(stdout.getvalue(), end="")
+if stderr.getvalue():
+    print(stderr.getvalue(), end="", file=sys.stderr)
 
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Lưu file đính kèm vào thư mục tạm
-        if attached_files is not None:
-            for file in attached_files:
-                filename = os.path.basename(file.name)
-                dest_path = os.path.join(temp_dir, filename)
-                with open(dest_path, 'wb') as f:
-                    with open(file.name, 'rb') as src:
-                        f.write(src.read())
+# Đánh dấu return_value
+print("__RETURN_VALUE__:" + json.dumps(result_value))
+'''
+    return template
 
-        # Tạo file code.py
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, dir=temp_dir) as temp_file:
-            temp_file.write(final_code)
-            temp_file.flush()
+# ----------------- Executor -----------------
 
-            logger.debug(f"Generated code:\n{final_code}")
+def execute_code_input_stream(code, attached_files):
+    """Chạy code input + file đính kèm, stream log realtime"""
+    # AST transform dòng cuối
+    code = wrap_last_expr_with_return(code)
 
-            try:
-                result = subprocess.run(
-                    ['python3', temp_file.name],
-                    cwd=temp_dir,
-                    capture_output=True,
-                    text=True,
-                    timeout=180
-                )
-
-                try:
-                    output = json.loads(result.stdout)
-                    stdout = output.get('stdout', '')
-                    stderr = output.get('stderr', '')
-                    return_value = output.get('return_value', None)
-
-                    log_lines = []
-                    if stdout.strip():
-                        log_lines.append(stdout.rstrip())
-                    if stderr.strip():
-                        log_lines.append(stderr.rstrip())
-                    log_text = "\n".join(log_lines)
-
-                    return_display = str(return_value) if return_value is not None else ""
-                    return log_text, return_display
-
-                except json.JSONDecodeError:
-                    return f"Error: Failed to parse result", ""
-
-            except subprocess.TimeoutExpired:
-                return f"Error: Execution timed out after 3 minutes", ""
-            except Exception as e:
-                return f"Error: {str(e)}", ""
-            finally:
-                try:
-                    os.unlink(temp_file.name)
-                except:
-                    pass
-
-
-def execute_uploaded_files(files, main_file):
-    """Chạy file upload"""
-    if not files:
-        return "Error: No files uploaded", ""
+    final_code = wrap_code_for_execution(code)
 
     with tempfile.TemporaryDirectory() as temp_dir:
-        if len(files) == 1 and files[0].name.endswith('.zip'):
-            try:
-                with zipfile.ZipFile(files[0].name, 'r') as zip_ref:
-                    zip_ref.extractall(temp_dir)
-            except Exception as e:
-                return f"Error extracting zip: {str(e)}", ""
-        else:
-            for file in files:
-                filename = os.path.basename(file.name)
-                dest_path = os.path.join(temp_dir, filename)
-                with open(dest_path, 'wb') as f:
-                    with open(file.name, 'rb') as src:
-                        f.write(src.read())
-
-        main_path = os.path.join(temp_dir, main_file)
-        if not os.path.exists(main_path):
-            return f"Error: Main file '{main_file}' not found", ""
-
-        try:
-            result = subprocess.run(
-                ['python3', main_path],
-                cwd=temp_dir,
-                capture_output=True,
-                text=True,
-                timeout=180
-            )
-
-            stdout = result.stdout if result.stdout else ""
-            stderr = result.stderr if result.stderr else ""
-
-            log_lines = []
-            if stdout.strip():
-                log_lines.append(stdout.rstrip())
-            if stderr.strip():
-                log_lines.append(stderr.rstrip())
-            log_text = "\n".join(log_lines)
-
-            return log_text, ""
+        # Lưu file đính kèm nếu có
+        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
+        process = subprocess.Popen(
+            ["python3", script_path],
+            cwd=temp_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+
+        return_value = None
+        for line in process.stdout:
+            line = line.rstrip("\n")
+            if line.startswith("__RETURN_VALUE__:"):
+                try:
+                    return_value = json.loads(line.replace("__RETURN_VALUE__:", "", 1))
+                except Exception:
+                    return_value = None
+            else:
+                yield line
 
-        except subprocess.TimeoutExpired:
-            return f"Error: Execution timed out after 3 minutes", ""
-        except Exception as e:
-            return f"Error: {str(e)}", ""
+        process.wait()
+        if return_value is not None:
+            yield f"[Return Value] {return_value}"
+        elif process.returncode != 0:
+            yield f"[Process exited with code {process.returncode}]"
 
+# ----------------- Gradio UI -----------------
 
-# Examples
 code_examples = [
     "1 + 1",
-    "print('Hello World!')",
-    "x = 5\ny = 10\nx + y",
+    "a = 5\na",
+    "print('Hello')\n3 * 3",
     "for i in range(3):\n    print(i)"
 ]
 
-file_examples = [
-    [["examples/hello.py"], "hello.py"],
-]
-
-# Giao diện
 with gr.Blocks(theme=gr.themes.Default(primary_hue="red")) as demo:
-    gr.Markdown("# 🔴 Python Code Executor")
-    gr.Markdown("Run Python code - Choose your preferred method")
-
-    with gr.Tabs():
-        with gr.Tab("⌨️ Direct Code Input"):
-            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_count="multiple"
-                    )
-
-                    run_code_btn = gr.Button("▶️ Run Code", variant="primary")
+    gr.Markdown("# 🔴 Python Executor (Stream Realtime + Return Last Expression)")
+
+    with gr.Row():
+        with gr.Column():
+            code_input = gr.Code(
+                label="Python Code",
+                language="python",
+                interactive=True
+            )
 
-                    gr.Markdown("### 📝 Examples:")
-                    examples_component = gr.Examples(
-                        examples=[[ex] for ex in code_examples],  # ép mỗi ví dụ thành 1 list => hiển thị dọc
-                        inputs=[code_input],
-                        label=None,
-                        examples_per_page=10,
-                    )
+            attached_files = gr.File(
+                label="📎 Attach Files (optional)",
+                file_count="multiple"
+            )
 
-                with gr.Column():
-                    log1 = gr.Textbox(label="Execution Log", lines=10)
-                    result1 = gr.Textbox(label="Return Value")
+            run_code_btn = gr.Button("▶️ Run Code", variant="primary")
 
-            run_code_btn.click(
-                execute_code_input,
-                [code_input, attached_files],
-                [log1, result1]
+            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,
             )
 
-        with gr.Tab("📁 Upload Files"):
-            with gr.Row():
-                with gr.Column():
-                    files_upload = gr.File(
-                        label="Upload Python Files (.py) or ZIP",
-                        file_types=[".py", ".zip"],
-                        file_count="multiple"
-                    )
-                    main_file_input = gr.Textbox(
-                        label="Main File Name (with .py)",
-                        value="main.py",
-                        placeholder="e.g., main.py"
-                    )
-                    run_files_btn = gr.Button("▶️ Run Files", variant="primary")
-                    gr.Markdown("### 📝 Instructions:")
-                    gr.Markdown("- Upload multiple .py files and specify main file")
-                    gr.Markdown("- Or upload a single .zip file with all Python files")
+        with gr.Column():
+            log1 = gr.Textbox(label="Execution Log", lines=15)
 
-                with gr.Column():
-                    log2 = gr.Textbox(label="Execution Log", lines=10)
-                    result2 = gr.Textbox(label="Return Value")
-
-            run_files_btn.click(
-                execute_uploaded_files,
-                [files_upload, main_file_input],
-                [log2, result2]
-            )
+    run_code_btn.click(
+        execute_code_input_stream,
+        [code_input, attached_files],
+        log1,
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()