app.py

import gradio as gr
import requests
import re
import os
import subprocess
import tempfile
import sys
import json
import time
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
running_process = None

# Clean up running process on exit
def cleanup_process():
    global running_process
    if running_process and running_process.poll() is None:
        try:
            running_process.terminate()
            running_process.wait(timeout=5)
            print(f"Terminated process {running_process.pid}")
        except Exception as e:
            print(f"Error terminating process: {e}")

atexit.register(cleanup_process)

def call_openai_api(api_key, prompt):
    """Call OpenAI API to generate Gradio app code and requirements"""
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    system_prompt = """You are an expert at creating Python applications with Gradio.
Create a complete, standalone Gradio application based on the user's prompt.

Provide your response in the following JSON format:
{
    "app_code": "# Python code here...",
    "requirements": ["gradio==3.32.0", "other_packages"],
    "description": "Brief description of what the app does"
}

Important guidelines:
1. The app_code should be a complete Gradio application
2. Use ONLY gr.Interface (NOT gr.Blocks)
3. Always include server_name="0.0.0.0" and server_port=7861 in the launch parameters
4. First requirement must be exactly "gradio==3.32.0"
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

Example:
```python
import gradio as gr
import numpy as np

def process(input_value):
    return input_value * 2

demo = gr.Interface(
    fn=process,
    inputs=gr.Number(label="Input"),
    outputs=gr.Number(label="Output"),
    title="Number Doubler"
)

demo.launch(server_name="0.0.0.0", server_port=7861)
```
"""
    
    data = {
        "model": "gpt-4o",
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.2,
        "max_tokens": 4000
    }
    
    try:
        response = requests.post(
            "https://api.openai.com/v1/chat/completions",
            headers=headers,
            json=data
        )
        
        if response.status_code != 200:
            return None, f"API Error: {response.status_code} - {response.text}"
        
        result = response.json()
        content = result["choices"][0]["message"]["content"]
        
        # Try to parse the JSON response
        try:
            # Look for JSON object
            json_pattern = r'({[\s\S]*})'
            json_match = re.search(json_pattern, content)
            
            if json_match:
                json_str = json_match.group(1)
                app_info = json.loads(json_str)
            else:
                # Try to extract code and requirements manually
                code_pattern = r'```python\s*([\s\S]*?)```'
                code_match = re.search(code_pattern, content)
                
                if not code_match:
                    return None, "No code found in the response"
                
                code = code_match.group(1)
                
                # Extract requirements from imports
                req_pattern = r'import\s+([a-zA-Z0-9_]+)'
                req_matches = re.findall(req_pattern, code)
                
                requirements = ["gradio==3.32.0"]
                for module in req_matches:
                    if module != "gradio" and module not in requirements and module not in ["os", "sys"]:
                        requirements.append(module)
                
                app_info = {
                    "app_code": code,
                    "requirements": requirements,
                    "description": "Generated Gradio application"
                }
            
            # Clean up the code if needed
            if "```python" in app_info["app_code"]:
                code_pattern = r'```python\s*([\s\S]*?)```'
                code_match = re.search(code_pattern, app_info["app_code"])
                if code_match:
                    app_info["app_code"] = code_match.group(1)
            
            return app_info, None
        except Exception as e:
            return None, f"Failed to parse API response: {str(e)}"
    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
    
    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)}"

def stop_running_app():
    """Stop the running app"""
    global running_process
    
    if running_process and running_process.poll() is None:
        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)}")
    
    running_process = None
    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, installs required packages,
    and runs it directly. The generated app will be displayed below.
    """)
    
    with gr.Row():
        with gr.Column(scale=1):
            api_key = gr.Textbox(
                label="OpenAI API Key", 
                placeholder="sk-...",
                type="password",
                info="Your key is used only for this session"
            )
            
            prompt = gr.Textbox(
                label="App Description", 
                placeholder="Describe the Gradio app you want to create...",
                lines=5
            )
            
            with gr.Row():
                generate_btn = gr.Button("Generate & Run App", variant="primary")
                stop_btn = gr.Button("Stop Running App", variant="stop", visible=False)
            
            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)
            
            status_output = gr.Markdown("")
        
        with gr.Column(scale=2):
            # 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_state = gr.State(None)
    
    def on_generate(api_key_val, prompt_val):
        # 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", 
                "<div style='text-align:center; padding:50px;'><h3>Invalid API key</h3></div>",
                gr.update(visible=False), None
            )
        
        try:
            # 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, 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'}", 
                    "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>",
                    gr.update(visible=False), None
                )
            
            code = app_info["app_code"]
            requirements = app_info["requirements"]
            
            # Make sure server_name and server_port are specified
            if "server_name" not in code or "server_port" not in code:
                if "demo.launch(" in code:
                    code = code.replace("demo.launch(", "demo.launch(server_name=\"0.0.0.0\", server_port=7861, ")
                else:
                    code += "\n\ndemo.launch(server_name=\"0.0.0.0\", server_port=7861)"
            
            status_message = "⏳ Installing packages and starting app..."
            yield (
                code, None, status_message,
                "<div style='text-align:center; padding:50px;'><h3>Installing packages...</h3></div>",
                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:
                return (
                    code, None, f"⚠️ {run_error}",
                    "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
                    gr.update(visible=False), None
                )
            
            # Show the app in an iframe
            iframe_html = f"""
            <div style="height:600px; border:1px solid #ddd; border-radius:5px; overflow:hidden;">
                <iframe src="http://localhost:7861" width="100%" height="100%" frameborder="0"></iframe>
            </div>
            """
            
            return (
                code, run_result["install_output"], f"✅ App is running! View it below.", 
                iframe_html, gr.update(visible=True), run_result["app_file"]
            )
        except Exception as e:
            import traceback
            error_details = traceback.format_exc()
            return (
                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), None
            )
    
    def on_stop(app_file):
        stopped = stop_running_app()
        
        # Clean up the app file
        if app_file and os.path.exists(app_file):
            try:
                os.unlink(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
            )
    
    generate_btn.click(
        on_generate,
        inputs=[api_key, prompt],
        outputs=[
            code_output, install_output, status_output, app_frame, 
            stop_btn, app_file_state
        ]
    )
    
    stop_btn.click(
        on_stop,
        inputs=[app_file_state],
        outputs=[status_output, app_frame, 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)