fix queue

app.py

@@ -1,22 +1,27 @@
+import concurrent.futures
 import gradio as gr
 import subprocess
 import tempfile
 import shutil
 import traceback
 import importlib.util
+import time
 
 class CodeExecutor:
     def __init__(self):
         self.temp_dir = tempfile.TemporaryDirectory()
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
 
     def _install_packages(self, packages):
         for package in packages:
             try:
                 spec = importlib.util.find_spec(package)
                 if spec is None:
-                    subprocess.check_call(["pip", "install", package], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                    subprocess.check_call(["pip", "install", package], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10)
             except subprocess.CalledProcessError as e:
                 raise Exception(f"Error installing package {package}: {e}")
+            except subprocess.TimeoutExpired:
+                raise Exception(f"Timed out installing package {package}")
 
     def _execute_code(self, code, inputs):
         temp_file = f"{self.temp_dir.name}/temp.py"
@@ -33,7 +38,9 @@ class CodeExecutor:
                         process.stdin.write(input_value.encode())
                         process.stdin.write(b"\n")
                 process.stdin.close()
-                process.wait()
+                process.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                raise Exception("Timed out executing code")
             except Exception as e:
                 error.write(traceback.format_exc())
 
@@ -45,26 +52,25 @@ class CodeExecutor:
             return f"User Code:\n{code}\n\nInputs:\n{', '.join(inputs)}\n\nOutput:\n{output_text}"
 
     def execute(self, code, inputs, packages):
+        future = self.executor.submit(self._execute_code, code, inputs)
         try:
-            if not packages:
-                packages = []
-            else:
-                packages = [p.strip() for p in packages.split(",")]
-            self._install_packages(packages)
-            input_values = [i.strip() for i in inputs.split(",")] if inputs else []
-            output = self._execute_code(code, input_values)
-            return output
+            output = future.result(timeout=10)
+        except concurrent.futures.TimeoutError:
+            raise Exception("Timed out waiting for code execution")
         except Exception as e:
-            return f"Error: {str(e)}"
+            raise Exception(f"Error: {str(e)}")
         finally:
-            shutil.rmtree(self.temp_dir.name)
+            if packages:
+                self._install_packages(packages.split(","))
+        return output
 
     def __del__(self):
+        self.executor.shutdown(wait=False)
         shutil.rmtree(self.temp_dir.name)
 
 def wrapper_execute(code, inputs, packages):
     executor = CodeExecutor()
-    return executor.execute(code, inputs, packages)
+    return executor.execute(code, inputs.split(","), packages)
 
 def create_interface():
     with gr.Blocks() as demo: