Update app.py

app.py

@@ -7,18 +7,22 @@ import tempfile
 import sys
 import json
 import time
+import threading
+import queue
 import atexit
 
 # Print Python version and gradio version for debugging
 print(f"Python version: {sys.version}")
 print(f"Gradio version: {gr.__version__}")
 
-# Track running processes for cleanup
+# Track running processes and resources for cleanup
 running_process = None
+temp_files = []
 
-# Clean up running process on exit
-def cleanup_process():
-    global running_process
+# Clean up resources on exit
+def cleanup_resources():
+    global running_process, temp_files
+    # Stop any running process
     if running_process and running_process.poll() is None:
         try:
             running_process.terminate()
@@ -26,8 +30,34 @@ def cleanup_process():
             print(f"Terminated process {running_process.pid}")
         except Exception as e:
             print(f"Error terminating process: {e}")
+    
+    # Remove temporary files
+    for file_path in temp_files:
+        if os.path.exists(file_path):
+            try:
+                os.unlink(file_path)
+                print(f"Removed temporary file: {file_path}")
+            except Exception as e:
+                print(f"Error removing file {file_path}: {e}")
+
+atexit.register(cleanup_resources)
+
+# Queue for capturing subprocess output
+output_queue = queue.Queue()
 
-atexit.register(cleanup_process)
+def read_output(process, output_queue):
+    """Read output from a process and put it in a queue"""
+    for line in iter(process.stdout.readline, ''):
+        if line:
+            output_queue.put(line)
+    process.stdout.close()
+
+def read_error(process, output_queue):
+    """Read error output from a process and put it in a queue"""
+    for line in iter(process.stderr.readline, ''):
+        if line:
+            output_queue.put(f"ERROR: {line}")
+    process.stderr.close()
 
 def call_openai_api(api_key, prompt):
     """Call OpenAI API to generate Gradio app code and requirements"""
@@ -54,6 +84,7 @@ Important guidelines:
 5. Keep the app simple and focused on the user's request
 6. DO NOT use any flagging callbacks
 7. DO NOT create or use any directories or file paths
+8. Do not use features from newer Gradio versions
 
 Example:
 ```python
@@ -144,83 +175,107 @@ demo.launch(server_name="0.0.0.0", server_port=7861)
     except Exception as e:
         return None, f"API call failed: {str(e)}"
 
-def install_and_run_app(code, requirements):
-    """Install requirements and run the app in a subprocess"""
-    global running_process
+def install_package(package, output_queue):
+    """Install a package and send output to the queue"""
+    cmd = [sys.executable, "-m", "pip", "install", "--upgrade", package]
+    print(f"Installing: {package}")
+    output_queue.put(f"Installing: {package}\n")
     
-    try:
-        # Clean up any previous process
-        if running_process and running_process.poll() is None:
-            running_process.terminate()
-            running_process.wait(timeout=5)
-        
-        # Create a temporary file for the app
-        fd, app_file = tempfile.mkstemp(suffix='.py')
-        os.close(fd)
-        
-        with open(app_file, 'w') as f:
-            f.write(code)
-        
-        # Install requirements
-        install_output = ""
-        for req in requirements:
-            try:
-                cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--no-cache-dir", req]
-                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=120)
-                install_output += f"Installing {req}: {'SUCCESS' if result.returncode == 0 else 'FAILED'}\n"
-                if result.returncode != 0:
-                    install_output += f"Error: {result.stderr}\n"
-            except Exception as e:
-                install_output += f"Error installing {req}: {str(e)}\n"
-        
-        # Run the app
-        running_process = subprocess.Popen(
-            [sys.executable, app_file],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
-        
-        # Wait a bit for the app to start
-        time.sleep(5)
-        
-        # Check if the process is still running
-        if running_process.poll() is not None:
-            stdout, stderr = running_process.communicate()
-            os.unlink(app_file)
-            return None, f"App failed to start:\n{stderr}\n\nInstallation log:\n{install_output}"
-        
-        return {
-            "app_file": app_file,
-            "install_output": install_output
-        }, None
-    except Exception as e:
-        if 'app_file' in locals() and os.path.exists(app_file):
-            os.unlink(app_file)
-        return None, f"Error setting up and running app: {str(e)}"
+    process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1
+    )
+    
+    # Start threads to read output
+    stdout_thread = threading.Thread(target=read_output, args=(process, output_queue))
+    stderr_thread = threading.Thread(target=read_error, args=(process, output_queue))
+    
+    stdout_thread.daemon = True
+    stderr_thread.daemon = True
+    
+    stdout_thread.start()
+    stderr_thread.start()
+    
+    # Wait for the process to complete
+    process.wait()
+    
+    # Wait for threads to finish
+    stdout_thread.join()
+    stderr_thread.join()
+    
+    if process.returncode == 0:
+        output_queue.put(f"Successfully installed {package}\n")
+        return True
+    else:
+        output_queue.put(f"Failed to install {package} (error code: {process.returncode})\n")
+        return False
 
-def stop_running_app():
-    """Stop the running app"""
-    global running_process
+def run_app(app_code, output_queue):
+    """Run the app in a separate process"""
+    global running_process, temp_files
     
+    # Stop any existing process
     if running_process and running_process.poll() is None:
+        running_process.terminate()
         try:
-            running_process.terminate()
             running_process.wait(timeout=5)
-            running_process = None
-            return True
-        except Exception as e:
-            print(f"Error stopping app: {str(e)}")
+        except subprocess.TimeoutExpired:
+            running_process.kill()
+    
+    # Create a temporary file for the app
+    fd, app_file = tempfile.mkstemp(suffix='.py')
+    os.close(fd)
+    
+    with open(app_file, 'w') as f:
+        f.write(app_code)
+    
+    temp_files.append(app_file)
+    
+    # Make sure the code has the correct launch parameters
+    if "demo.launch" not in app_code:
+        with open(app_file, 'a') as f:
+            f.write("\n\ndemo.launch(server_name='0.0.0.0', server_port=7861)\n")
+    
+    # Run the app
+    output_queue.put(f"Starting the app...\n")
+    running_process = subprocess.Popen(
+        [sys.executable, app_file],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1
+    )
+    
+    # Start threads to read output
+    stdout_thread = threading.Thread(target=read_output, args=(running_process, output_queue))
+    stderr_thread = threading.Thread(target=read_error, args=(running_process, output_queue))
+    
+    stdout_thread.daemon = True
+    stderr_thread.daemon = True
     
-    running_process = None
-    return False
+    stdout_thread.start()
+    stderr_thread.start()
+    
+    # Wait a bit for the app to start
+    time.sleep(5)
+    
+    # Check if the process is still running
+    if running_process.poll() is not None:
+        output_queue.put(f"App failed to start (error code: {running_process.returncode})\n")
+        return False, app_file
+    
+    output_queue.put(f"App is running on port 7861\n")
+    return True, app_file
 
 # Create the Gradio interface
 with gr.Blocks(title="Gradio App Generator") as demo:
     gr.Markdown("# 🤖 Gradio App Generator")
     gr.Markdown("""
     This app generates a Gradio application based on your description, installs required packages,
-    and runs it directly. The generated app will be displayed below.
+    and runs it directly within this container. The generated app will be displayed below.
     """)
     
     with gr.Row():
@@ -245,8 +300,13 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             with gr.Accordion("Generated Code", open=False):
                 code_output = gr.Code(language="python", label="App Code")
             
-            with gr.Accordion("Installation Log", open=False):
-                install_output = gr.Textbox(label="Package Installation Log", lines=5)
+            progress_output = gr.Textbox(
+                label="Progress Log", 
+                lines=10,
+                max_lines=20,
+                autoscroll=True,
+                interactive=False
+            )
             
             status_output = gr.Markdown("")
         
@@ -254,15 +314,20 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             # Frame to display the running app
             app_frame = gr.HTML("<div style='text-align:center; padding:50px;'><h3>Your generated app will appear here</h3></div>")
     
-    # App file path storage
+    # App file storage
     app_file_state = gr.State(None)
     
     def on_generate(api_key_val, prompt_val):
+        # Initialize output queue
+        global output_queue
+        output_queue = queue.Queue()
+        
         # Validate API key
         if not api_key_val or len(api_key_val) < 20 or not api_key_val.startswith("sk-"):
             return (
-                None, None, "⚠️ Please provide a valid OpenAI API key", 
+                None, "⚠️ Please provide a valid OpenAI API key", 
                 "<div style='text-align:center; padding:50px;'><h3>Invalid API key</h3></div>",
+                "Please enter a valid OpenAI API key",
                 gr.update(visible=False), None
             )
         
@@ -270,16 +335,18 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             # Generate app code and requirements
             status_message = "⏳ Generating app code..."
             yield (
-                None, None, status_message, 
+                None, status_message, 
                 "<div style='text-align:center; padding:50px;'><h3>Generating code...</h3></div>",
+                "Generating app code...",
                 gr.update(visible=False), None
             )
             
             app_info, error = call_openai_api(api_key_val, prompt_val)
             if error or not app_info:
                 return (
-                    None, None, f"⚠️ {error or 'Failed to generate app'}", 
+                    None, f"⚠️ {error or 'Failed to generate app'}", 
                     "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>",
+                    f"Error: {error or 'Failed to generate app'}",
                     gr.update(visible=False), None
                 )
             
@@ -293,19 +360,66 @@ with gr.Blocks(title="Gradio App Generator") as demo:
                 else:
                     code += "\n\ndemo.launch(server_name=\"0.0.0.0\", server_port=7861)"
             
-            status_message = "⏳ Installing packages and starting app..."
+            status_message = "⏳ Installing packages..."
             yield (
-                code, None, status_message,
+                code, status_message,
                 "<div style='text-align:center; padding:50px;'><h3>Installing packages...</h3></div>",
+                "Starting package installation...",
+                gr.update(visible=False), None
+            )
+            
+            # Install packages one by one with real-time updates
+            install_results = []
+            for i, package in enumerate(requirements):
+                success = install_package(package, output_queue)
+                install_results.append(success)
+                
+                # Update the progress output
+                progress_text = ""
+                while not output_queue.empty():
+                    progress_text += output_queue.get_nowait()
+                
+                yield (
+                    code, f"⏳ Installing packages ({i+1}/{len(requirements)})...",
+                    "<div style='text-align:center; padding:50px;'><h3>Installing packages...</h3></div>",
+                    progress_text,
+                    gr.update(visible=False), None
+                )
+            
+            # Check if all packages were installed successfully
+            if not all(install_results):
+                progress_text = ""
+                while not output_queue.empty():
+                    progress_text += output_queue.get_nowait()
+                
+                return (
+                    code, "⚠️ Some packages failed to install",
+                    "<div style='text-align:center; padding:50px;'><h3>Error installing packages</h3></div>",
+                    progress_text,
+                    gr.update(visible=False), None
+                )
+            
+            status_message = "⏳ Starting the app..."
+            yield (
+                code, status_message,
+                "<div style='text-align:center; padding:50px;'><h3>Starting app...</h3></div>",
+                progress_text,
                 gr.update(visible=False), None
             )
             
-            # Install packages and run the app
-            run_result, run_error = install_and_run_app(code, requirements)
-            if run_error or not run_result:
+            # Run the app
+            success, app_file = run_app(code, output_queue)
+            
+            # Update the progress output again
+            progress_text = ""
+            while not output_queue.empty():
+                progress_text += output_queue.get_nowait()
+            
+            if not success:
                 return (
-                    code, None, f"⚠️ {run_error}",
-                    "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
+                    code, "⚠️ Failed to start the app",
+                    "<div style='text-align:center; padding:50px;'><h3>Error starting app</h3></div>",
+                    progress_text,
                     gr.update(visible=False), None
                 )
             
@@ -317,56 +431,67 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             """
             
             return (
-                code, run_result["install_output"], f"✅ App is running! View it below.", 
-                iframe_html, gr.update(visible=True), run_result["app_file"]
+                code, f"✅ App is running! View it below.", 
+                iframe_html,
+                progress_text,
+                gr.update(visible=True), app_file
             )
         except Exception as e:
             import traceback
             error_details = traceback.format_exc()
             return (
-                None, None, f"⚠️ Error: {str(e)}\n\n{error_details}",
+                None, f"⚠️ Error: {str(e)}",
                 "<div style='text-align:center; padding:50px;'><h3>An error occurred</h3></div>",
+                f"Error: {str(e)}\n\n{error_details}",
                 gr.update(visible=False), None
             )
     
     def on_stop(app_file):
-        stopped = stop_running_app()
+        global running_process
+        
+        if running_process and running_process.poll() is None:
+            running_process.terminate()
+            try:
+                running_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                running_process.kill()
+            
+            running_process = None
         
         # Clean up the app file
         if app_file and os.path.exists(app_file):
             try:
                 os.unlink(app_file)
+                if app_file in temp_files:
+                    temp_files.remove(app_file)
             except:
                 pass
         
-        if stopped:
-            return (
-                "✅ App stopped successfully", 
-                "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
-                gr.update(visible=False), None
-            )
-        else:
-            return (
-                "⚠️ No app was running", 
-                "<div style='text-align:center; padding:50px;'><h3>No app was running</h3></div>",
-                gr.update(visible=False), None
-            )
+        return (
+            "✅ App stopped", 
+            "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
+            "App has been stopped",
+            gr.update(visible=False), None
+        )
     
     generate_btn.click(
         on_generate,
         inputs=[api_key, prompt],
         outputs=[
-            code_output, install_output, status_output, app_frame, 
-            stop_btn, app_file_state
+            code_output, status_output, app_frame, 
+            progress_output, stop_btn, app_file_state
         ]
     )
     
     stop_btn.click(
         on_stop,
         inputs=[app_file_state],
-        outputs=[status_output, app_frame, stop_btn, app_file_state]
+        outputs=[
+            status_output, app_frame, progress_output,
+            stop_btn, app_file_state
+        ]
     )
 
 if __name__ == "__main__":
     # Make sure we're not trying to use flagging
-    demo.launch(server_name="0.0.0.0", server_port=7860, flagging_callback=None)
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, flagging_callback=None)