fixed

app.py

@@ -1,57 +1,94 @@
 import gradio as gr
 import subprocess
 import tempfile
+import shutil
 import traceback
 
-
 class CodeExecutor:
     def __init__(self):
         self.temp_dir = tempfile.TemporaryDirectory()
 
-    def execute(self, code, inputs):
-        input_file = f"{self.temp_dir.name}/input.txt"
-        with open(input_file, "w") as f:
-            f.write(inputs)
+    def _install_packages(self, packages):
+        for package in packages:
+            try:
+                subprocess.check_call(["pip", "install", package], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except subprocess.CalledProcessError as e:
+                raise Exception(f"Error installing package {package}: {e}")
+
+    def _uninstall_packages(self, packages):
+        for package in packages:
+            try:
+                subprocess.check_call(["pip", "uninstall", "-y", package], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except subprocess.CalledProcessError as e:
+                raise Exception(f"Error uninstalling package {package}: {e}")
+
+    def _execute_code(self, code, inputs):
+        temp_file = f"{self.temp_dir.name}/temp.py"
+        with open(temp_file, "w") as f:
+            f.write(code)
 
         output_file = f"{self.temp_dir.name}/output.txt"
         error_file = f"{self.temp_dir.name}/error.txt"
+        with open(output_file, "w") as output, open(error_file, "w") as error:
+            try:
+                process = subprocess.Popen(["python", temp_file], stdin=subprocess.PIPE, stdout=output, stderr=error)
+                if inputs:
+                    for input_value in inputs:
+                        process.stdin.write(input_value.encode())
+                        process.stdin.write(b"\n")
+                process.stdin.close()
+                process.wait()
+            except Exception as e:
+                error.write(traceback.format_exc())
+
+        with open(output_file, "r") as output, open(error_file, "r") as error:
+            output_text = output.read()
+            error_text = error.read()
+            if error_text:
+                return f"{code}\n\nTraceback (most recent call last):\n{error_text}"
+            return f"{code}\n\nOutput:\n{output_text}"
+
+    def execute(self, code, inputs, packages):
         try:
-            with open(output_file, "w") as f, open(error_file, "w") as e:
-                subprocess.run(
-                    ["python", "-c", code], check=True, timeout=5, stdin=open(input_file, "r"), stdout=f, stderr=e
-                )
-            with open(output_file, "r") as f:
-                output = f.read()
-            with open(error_file, "r") as f:
-                error = f.read()
-            if error:
-                output = f"Error:\n{error}"
-        except subprocess.CalledProcessError as e:
-            output = f"Error:\n{e}\n\n{traceback.format_exc()}"
-        except subprocess.TimeoutExpired:
-            output = "Execution timed out."
+            if not packages:
+                packages = []
+            else:
+                packages = [p.strip() for p in packages.split(",")]
+            if packages:
+                self._install_packages(packages)
+            input_values = [i.strip() for i in inputs.split(",")] if inputs else []
+            output = self._execute_code(code, input_values)
+            if packages:
+                self._uninstall_packages(packages)
+            return output
         except Exception as e:
-            output = f"Error:\n{e}\n\n{traceback.format_exc()}"
+            return f"Error: {str(e)}"
+        finally:
+            shutil.rmtree(self.temp_dir.name)
 
-        return f"User's Code:\n```python\n{code}\n```\n\nOutput:\n{output}"
+    def __del__(self):
+        shutil.rmtree(self.temp_dir.name)
 
+def wrapper_execute(code, inputs, packages):
+    executor = CodeExecutor()
+    return executor.execute(code, inputs, packages)
 
 def create_interface():
     with gr.Blocks() as demo:
         gr.Markdown("# Code Interpreter")
-        gr.Markdown("Enter Python code and inputs to execute.")
-        code_input = gr.Code(language="python", label="Code")
-        inputs_input = gr.Textbox(label="Inputs")
-        output_text = gr.Textbox(label="Output", lines=20)
+        gr.Markdown("Enter Python code and inputs to execute")
+        code_input = gr.Textbox(label="Code", lines=20)
+        inputs_input = gr.Textbox(label="Inputs (comma-separated)", lines=1)
+        packages_input = gr.Textbox(label="Install Packages (comma-separated)", lines=1)
+        output_text = gr.Text(label="Output", lines=20)
         run_button = gr.Button("Run")
         run_button.click(
-            CodeExecutor().execute, inputs=[code_input, inputs_input], outputs=output_text
+            wrapper_execute,
+            inputs=[code_input, inputs_input, packages_input],
+            outputs=output_text
         )
-        demo.inputs = [code_input, inputs_input]
-        demo.outputs = [output_text]
     return demo
 
-
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch()
+    demo = create_interface()
+    demo.launch()