Update app.py

app.py

@@ -3,34 +3,17 @@ import requests
 import re
 import os
 import subprocess
-import uuid
-import time
-import json
-import sys
-import importlib.util
 import tempfile
+import sys
+import json
+import time
 import signal
 import atexit
-from pathlib import Path
 
 # Print Python version info for debugging
 print(f"Python version: {sys.version}")
-print(f"Python executable: {sys.executable}")
 
-# Application directories
-APP_DIR = Path(os.getcwd())
-VENV_DIR = APP_DIR / "venvs"
-os.makedirs(VENV_DIR, exist_ok=True)
-
-# Make sure we have virtualenv installed
-try:
-    import venv
-    print("venv module available")
-except ImportError:
-    subprocess.run([sys.executable, "-m", "pip", "install", "virtualenv"], check=True)
-    print("Installed virtualenv")
-
-# Track running processes
+# Track running processes for cleanup
 running_processes = []
 
 # Clean up any running processes on exit
@@ -59,23 +42,22 @@ Your task is to create a complete, standalone Gradio application based on the us
 Provide your response in the following JSON format:
 {
     "app_code": "# Your Python code here...",
-    "requirements": ["gradio==3.50.2", "numpy", "pandas", ...],
+    "requirements": ["gradio==3.32.0", "numpy", "pandas", ...],
     "app_name": "descriptive-name-of-app",
     "description": "Brief description of what the app does"
 }
 
 Important guidelines:
 1. The app_code should be a complete Gradio application.
-2. Include gradio.launch(server_name="0.0.0.0", server_port=8000) at the end of the app.
+2. Include demo.launch(server_name="0.0.0.0", server_port=7861) at the end of the code
 3. Don't use any resource that requires internet access (no API calls).
 4. Only use libraries that can be installed via pip.
-5. First requirement should be gradio==3.50.2.
-6. Make sure your code only uses the import statements for packages in the requirements list.
-7. Make the app functionality self-contained and robust.
-8. Don't use any buttons' .click() methods or event handlers - use gr.Interface() instead.
+5. First requirement should be gradio==3.32.0 (important: use exactly this version).
+6. Use only gr.Interface instead of gr.Blocks to avoid version compatibility issues.
+7. Don't use any buttons' .click() methods or event handlers - use gr.Interface() only.
+8. Make the app functionality self-contained and robust.
 9. Don't create directories or write to any file paths.
 10. Don't use flagging callbacks or features.
-11. Don't use __name__ == "__main__" checks, just have the launch call at the end.
 
 Here's a simple template to follow:
 
@@ -97,7 +79,7 @@ demo = gr.Interface(
 )
 
 # Launch the app
-demo.launch(server_name="0.0.0.0", server_port=8000)
+demo.launch(server_name="0.0.0.0", server_port=7861)
 ```
 """
     
@@ -163,20 +145,20 @@ demo.launch(server_name="0.0.0.0", server_port=8000)
                 return None, "Could not extract app code from response"
             
             # Try to extract requirements
-            req_pattern = r'```(?:python)?\s*.*?import\s+([a-zA-Z0-9_]+)'
-            req_matches = re.findall(req_pattern, content)
+            req_pattern = r'import\s+([a-zA-Z0-9_]+)'
+            req_matches = re.findall(req_pattern, app_code)
             
-            requirements = ["gradio==3.50.2"]
+            requirements = ["gradio==3.32.0"]
             if req_matches:
                 for module in req_matches:
-                    if module != "gradio" and module not in requirements:
+                    if module != "gradio" and module not in requirements and module != "os" and module != "sys":
                         requirements.append(module)
             
             # Construct a partial app_info
             app_info = {
                 "app_code": app_code,
                 "requirements": requirements,
-                "app_name": f"gradio-app-{int(time.time())}",
+                "app_name": "gradio-app",
                 "description": "Generated Gradio application"
             }
             
@@ -184,115 +166,103 @@ demo.launch(server_name="0.0.0.0", server_port=8000)
     except Exception as e:
         return None, f"Error: {str(e)}"
 
-def create_virtual_env(app_info):
-    """Create a virtual environment with the required packages"""
+def install_and_run_app(app_code, requirements):
+    """Install requirements and run the app in a subprocess"""
     try:
-        # Create a unique ID for this app
-        app_id = str(uuid.uuid4())[:8]
-        app_name = f"{app_info['app_name']}-{app_id}"
-        venv_path = VENV_DIR / app_name
-        
-        # Create a virtual environment
-        print(f"Creating virtual environment at {venv_path}")
-        subprocess.run([sys.executable, "-m", "venv", str(venv_path)], check=True)
+        # Create a temporary directory for the app
+        temp_dir = tempfile.mkdtemp()
         
-        # Determine the pip executable path
-        if os.name == 'nt':  # Windows
-            pip_path = venv_path / "Scripts" / "pip"
-        else:  # Unix/Linux
-            pip_path = venv_path / "bin" / "pip"
+        # Create app file
+        app_file = os.path.join(temp_dir, "app.py")
+        with open(app_file, 'w') as f:
+            f.write(app_code)
         
-        # Install required packages
-        print(f"Installing packages: {', '.join(app_info['requirements'])}")
-        subprocess.run([str(pip_path), "install", "--upgrade", "pip"], check=True)
-        for req in app_info["requirements"]:
-            subprocess.run([str(pip_path), "install", req], check=True)
-        
-        return {
-            "app_id": app_id,
-            "app_name": app_name,
-            "venv_path": str(venv_path),
-            "pip_path": str(pip_path),
-            "description": app_info["description"],
-            "code": app_info["app_code"],
-            "requirements": app_info["requirements"]
-        }
-    except Exception as e:
-        return None, f"Error creating virtual environment: {str(e)}"
-
-def run_app_in_venv(app_details, app_code):
-    """Run the Gradio app in a virtual environment"""
-    try:
-        # Determine the Python executable path
-        if os.name == 'nt':  # Windows
-            python_path = Path(app_details["venv_path"]) / "Scripts" / "python"
-        else:  # Unix/Linux
-            python_path = Path(app_details["venv_path"]) / "bin" / "python"
-        
-        # Create a temporary file for the app code
-        with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
-            app_file = f.name
-            f.write(app_code.encode('utf-8'))
-        
-        # Change the port to 8000 if not already set
+        # Make sure port 7861 is specified
         if "server_port" not in app_code:
             with open(app_file, 'a') as f:
-                f.write("\n\n# Ensure the app is running on port 8000\nif 'demo' in locals():\n    demo.launch(server_name='0.0.0.0', server_port=8000)\n")
+                f.write("\n\n# Ensure the app is running on port 7861\n")
+                f.write("if 'demo' in locals():\n")
+                f.write("    demo.launch(server_name='0.0.0.0', server_port=7861)\n")
+        
+        # Install requirements
+        pip_output = ""
+        for req in requirements:
+            try:
+                cmd = [sys.executable, "-m", "pip", "install", req]
+                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                pip_output += f"Installing {req}: {'SUCCESS' if result.returncode == 0 else 'FAILED'}\n"
+                if result.returncode != 0:
+                    pip_output += f"Error: {result.stderr}\n"
+            except Exception as e:
+                pip_output += f"Error installing {req}: {str(e)}\n"
         
         # Run the app
-        print(f"Running app with Python: {python_path}")
-        process = subprocess.Popen(
-            [str(python_path), app_file],
-            stdout=subprocess.PIPE,
+        cmd = [sys.executable, app_file]
+        app_process = subprocess.Popen(
+            cmd, 
+            stdout=subprocess.PIPE, 
             stderr=subprocess.PIPE,
             text=True
         )
         
-        running_processes.append(process)
+        running_processes.append(app_process)
         
         # Wait a bit for the app to start
-        time.sleep(5)
+        time.sleep(3)
         
         # Check if the process is still running
-        if process.poll() is not None:
-            stdout, stderr = process.communicate()
-            return None, f"App failed to start: {stderr}"
+        if app_process.poll() is not None:
+            stdout, stderr = app_process.communicate()
+            return None, f"App failed to start:\n{stderr}\n\nInstallation log:\n{pip_output}"
         
         return {
-            "process": process,
+            "process": app_process,
             "app_file": app_file,
-            "url": "http://localhost:8000",
-            "process_id": process.pid
+            "temp_dir": temp_dir,
+            "url": "http://localhost:7861",
+            "pip_output": pip_output
         }, None
     except Exception as e:
-        return None, f"Error running app: {str(e)}"
+        return None, f"Error setting up and running app: {str(e)}"
 
-def stop_running_app(app_process):
-    """Stop a running Gradio app process"""
-    if app_process and app_process.poll() is None:
-        app_process.terminate()
-        try:
-            app_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            app_process.kill()
+def stop_running_app(app_details):
+    """Stop a running app and clean up"""
+    try:
+        if app_details and "process" in app_details:
+            process = app_details["process"]
+            if process.poll() is None:  # If process is still running
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                
+                if process in running_processes:
+                    running_processes.remove(process)
         
-        if app_process in running_processes:
-            running_processes.remove(app_process)
+        # Clean up temp directory
+        if app_details and "temp_dir" in app_details:
+            import shutil
+            try:
+                shutil.rmtree(app_details["temp_dir"])
+            except:
+                pass
         
         return True
-    return False
+    except Exception as e:
+        print(f"Error stopping app: {str(e)}")
+        return False
 
 # 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 and runs it in a virtual environment
-    with the required dependencies. The generated app will be displayed below.
+    This app generates a Gradio application based on your description, installs required packages,
+    and runs it directly within this container. The generated app will be displayed below.
     """)
     
-    # State variables to track the running app
-    running_app_process = gr.State(None)
-    running_app_file = gr.State(None)
+    # State variable to track running app details
+    app_details_state = gr.State(None)
     
     with gr.Row():
         with gr.Column(scale=1):
@@ -309,12 +279,6 @@ with gr.Blocks(title="Gradio App Generator") as demo:
                 lines=5
             )
             
-            install_bar = gr.HTML(
-                "<div id='install-status'></div>",
-                visible=False,
-                label="Installation Status"
-            )
-            
             with gr.Row():
                 generate_btn = gr.Button("Generate & Run App", variant="primary")
                 stop_btn = gr.Button("Stop Running App", variant="stop", visible=False)
@@ -322,8 +286,8 @@ 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("Requirements", open=False):
-                req_output = gr.Textbox(label="Required Packages")
+            with gr.Accordion("Package Installation Log", open=False):
+                install_output = gr.Textbox(label="Installation Log", lines=5)
             
             status_output = gr.Markdown("")
         
@@ -331,127 +295,107 @@ 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>")
     
-    def on_generate(api_key_val, prompt_val, running_process, app_file):
+    def on_generate(api_key_val, prompt_val, current_app_details):
         # Stop any previously running app
-        if running_process:
-            stop_running_app(running_process)
-        
-        # Clean up previous app file
-        if app_file and os.path.exists(app_file):
-            try:
-                os.unlink(app_file)
-            except:
-                pass
+        if current_app_details:
+            stop_running_app(current_app_details)
         
         # Validate API key
         if not api_key_val or len(api_key_val) < 20 or not api_key_val.startswith("sk-"):
             return (
-                None, None, None, "⚠️ Please provide a valid OpenAI API key", 
+                None, None, "⚠️ Please provide a valid OpenAI API key", 
                 "<div style='text-align:center; padding:50px;'><h3>Invalid API key</h3></div>",
-                gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                gr.update(visible=False), None
             )
         
         try:
-            # Generate code via API
+            # Call the OpenAI API to generate app code and requirements
+            status_message = "⏳ Generating app code..."
+            yield (
+                None, None, status_message, 
+                "<div style='text-align:center; padding:50px;'><h3>Generating code...</h3></div>",
+                gr.update(visible=False), None
+            )
+            
             app_info, api_error = call_openai_api(api_key_val, prompt_val)
             if api_error or not app_info:
                 return (
-                    None, None, None, f"⚠️ {api_error or 'Failed to generate app'}",
+                    None, None, f"⚠️ {api_error or 'Failed to generate app'}",
                     "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>",
-                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                    gr.update(visible=False), None
                 )
             
-            # Create virtual environment with required packages
-            install_status = f"<div style='padding:10px; background-color:#f0f0f0; border-radius:5px;'>"
-            install_status += f"<p>Creating virtual environment for '{app_info['app_name']}'...</p>"
-            install_status += f"<p>Installing packages: {', '.join(app_info['requirements'])}</p>"
-            install_status += "</div>"
+            # At this point we have app code and requirements
+            code = app_info["app_code"]
+            requirements = app_info["requirements"]
             
+            status_message = "⏳ Installing packages and starting app..."
             yield (
-                app_info["app_code"], "\n".join(app_info["requirements"]), None,
-                "⏳ Setting up virtual environment and installing packages...",
-                "<div style='text-align:center; padding:50px;'><h3>Preparing your app...</h3></div>",
-                gr.update(visible=True, value=install_status), gr.update(visible=False), running_process, app_file
+                code, None, status_message,
+                "<div style='text-align:center; padding:50px;'><h3>Installing packages...</h3></div>",
+                gr.update(visible=False), None
             )
             
-            venv_details, venv_error = create_virtual_env(app_info)
-            if venv_error or not venv_details:
-                return (
-                    app_info["app_code"], "\n".join(app_info["requirements"]), None,
-                    f"⚠️ {venv_error or 'Failed to create virtual environment'}",
-                    "<div style='text-align:center; padding:50px;'><h3>Error setting up environment</h3></div>",
-                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
-                )
-            
-            # Run the app
-            app_result, app_error = run_app_in_venv(venv_details, app_info["app_code"])
-            if app_error or not app_result:
+            # Install packages and run the app
+            app_details, run_error = install_and_run_app(code, requirements)
+            if run_error or not app_details:
                 return (
-                    app_info["app_code"], "\n".join(app_info["requirements"]), None,
-                    f"⚠️ {app_error or 'Failed to run app'}",
+                    code, None, f"⚠️ {run_error or 'Failed to run app'}",
                     "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
-                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                    gr.update(visible=False), None
                 )
             
-            # Display the running app in an iframe
+            # Create iframe to display the app
             iframe_html = f"""
             <div style="height:600px; border:1px solid #ddd; border-radius:5px; overflow:hidden;">
-                <iframe src="http://localhost:8000" width="100%" height="100%" frameborder="0"></iframe>
+                <iframe src="http://localhost:7861" width="100%" height="100%" frameborder="0"></iframe>
             </div>
             """
             
             return (
-                app_info["app_code"], "\n".join(app_info["requirements"]), None,
-                f"✅ App '{venv_details['app_name']}' is running! View it below.",
+                code, app_details["pip_output"], 
+                f"✅ App is running! View it below.", 
                 iframe_html,
-                gr.update(visible=False), gr.update(visible=True), app_result["process"], app_result["app_file"]
+                gr.update(visible=True), app_details
             )
         except Exception as e:
             import traceback
             error_details = traceback.format_exc()
             return (
-                None, None, None, f"⚠️ Error: {str(e)}\n\n{error_details}",
+                None, None, f"⚠️ Error: {str(e)}\n\n{error_details}",
                 "<div style='text-align:center; padding:50px;'><h3>An error occurred</h3></div>",
-                gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                gr.update(visible=False), None
             )
     
-    def on_stop(running_process, app_file):
-        if running_process:
-            stopped = stop_running_app(running_process)
-            
-            # Clean up app file
-            if app_file and os.path.exists(app_file):
-                try:
-                    os.unlink(app_file)
-                except:
-                    pass
-            
+    def on_stop(current_app_details):
+        if current_app_details:
+            stopped = stop_running_app(current_app_details)
             if stopped:
                 return (
                     "✅ App stopped successfully", 
                     "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
-                    gr.update(visible=False), None, None
+                    gr.update(visible=False), None
                 )
         
         return (
             "⚠️ No app was running", 
             "<div style='text-align:center; padding:50px;'><h3>No app was running</h3></div>",
-            gr.update(visible=False), None, None
+            gr.update(visible=False), None
         )
     
     generate_btn.click(
         on_generate,
-        inputs=[api_key, prompt, running_app_process, running_app_file],
+        inputs=[api_key, prompt, app_details_state],
         outputs=[
-            code_output, req_output, install_bar, status_output, app_frame, 
-            install_bar, stop_btn, running_app_process, running_app_file
+            code_output, install_output, status_output, app_frame, 
+            stop_btn, app_details_state
         ]
     )
     
     stop_btn.click(
         on_stop,
-        inputs=[running_app_process, running_app_file],
-        outputs=[status_output, app_frame, stop_btn, running_app_process, running_app_file]
+        inputs=[app_details_state],
+        outputs=[status_output, app_frame, stop_btn, app_details_state]
     )
 
 if __name__ == "__main__":