Update app.py

app.py

@@ -1,256 +1,185 @@
 import gradio as gr
-import requests
-import re
 import os
-import subprocess
 import tempfile
-import sys
-import json
+import requests
+import subprocess
+import re
 import time
+import sys
 
-# Print Python version and gradio version for debugging
-print(f"Python version: {sys.version}")
-print(f"Gradio version: {gr.__version__}")
-
-# Track running processes and files
-running_process = None
-temp_file = None
+# Global variables to track resources
+app_process = None
+temp_file_path = None
 
-def call_openai_api(api_key, prompt):
-    """Call OpenAI API to generate Gradio app code"""
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}"
-    }
+def cleanup():
+    """Clean up resources when the app exits"""
+    global app_process, temp_file_path
     
-    system_prompt = """You are an expert at creating Python applications with Gradio.
-Create a complete, standalone Gradio application based on the user's prompt.
-
-Important guidelines:
-1. Use ONLY gr.Interface (NOT gr.Blocks)
-2. Always include server_name="0.0.0.0" and server_port=7861 in the launch parameters
-3. Keep the app simple and focused on the user's request
-4. DO NOT use any flagging callbacks or flagging_dir parameters
-5. Use only standard Python libraries that come with Python
-6. Try to use the simplest possible implementation
-
-Example:
-```python
-import gradio as gr
-import numpy as np
-
-def process(input_value):
-    return input_value * 2
+    if app_process and app_process.poll() is None:
+        print("Stopping running process...")
+        app_process.terminate()
+        time.sleep(1)
+        if app_process.poll() is None:
+            app_process.kill()
+    
+    if temp_file_path and os.path.exists(temp_file_path):
+        print(f"Removing temp file: {temp_file_path}")
+        try:
+            os.unlink(temp_file_path)
+        except Exception as e:
+            print(f"Error removing temp file: {e}")
 
-demo = gr.Interface(
-    fn=process,
-    inputs=gr.Number(label="Input"),
-    outputs=gr.Number(label="Output"),
-    title="Number Doubler"
-)
+# Register cleanup function to run at exit
+import atexit
+atexit.register(cleanup)
 
-demo.launch(server_name="0.0.0.0", server_port=7861)
-```
-"""
+def get_app_code(api_key, description):
+    """Get app code from the OpenAI API"""
+    prompt = f"""Create a simple Gradio app that {description}.
+    
+    The app should:
+    1. Use ONLY gr.Interface (not Blocks)
+    2. Be self-contained and not use any external dependencies
+    3. Use only Python standard library and NumPy/Pandas if needed
+    4. Include demo.launch(server_name="0.0.0.0", server_port=7861) at the end
+    
+    Provide ONLY Python code with no explanation or markdown."""
     
     try:
         response = requests.post(
             "https://api.openai.com/v1/chat/completions",
-            headers=headers,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}"
+            },
             json={
                 "model": "gpt-4o",
                 "messages": [
-                    {"role": "system", "content": system_prompt},
+                    {"role": "system", "content": "You are a Gradio expert. Provide only Python code without explanations."},
                     {"role": "user", "content": prompt}
                 ],
-                "temperature": 0.2,
-                "max_tokens": 4000
+                "temperature": 0.2
             }
         )
         
         if response.status_code != 200:
-            return None, f"API Error: {response.status_code} - {response.text}"
+            return None, f"API Error: {response.status_code}"
         
-        result = response.json()
-        content = result["choices"][0]["message"]["content"]
+        content = response.json()["choices"][0]["message"]["content"]
         
-        # Extract code from the response
+        # Extract code blocks if present
         code_pattern = r'```python\s*([\s\S]*?)```'
-        code_match = re.search(code_pattern, content)
+        code_matches = re.findall(code_pattern, content)
+        
+        if code_matches:
+            return code_matches[0], None
         
-        if code_match:
-            return code_match.group(1), None
-        else:
-            # If no code block found, use the entire content
-            return content, None
+        # If no code blocks found, use the whole content
+        return content, None
+    
     except Exception as e:
-        return None, f"API call failed: {str(e)}"
+        return None, f"Error: {str(e)}"
 
-def run_app(code):
-    """Run the Gradio app in a subprocess"""
-    global running_process, temp_file
+def run_gradio_app(code):
+    """Save the code to a temp file and run it as a subprocess"""
+    global app_process, temp_file_path
     
-    # Stop any previously running process
-    if running_process and running_process.poll() is None:
-        running_process.terminate()
+    # Stop any existing process
+    if app_process and app_process.poll() is None:
+        app_process.terminate()
         time.sleep(1)
-        if running_process.poll() is None:
-            running_process.kill()
+        if app_process.poll() is None:
+            app_process.kill()
     
-    # Clean up previous temp file
-    if temp_file and os.path.exists(temp_file):
+    # Remove any existing temp file
+    if temp_file_path and os.path.exists(temp_file_path):
         try:
-            os.unlink(temp_file)
+            os.unlink(temp_file_path)
         except:
             pass
     
-    # Create a temporary file for the app
-    fd, temp_file = tempfile.mkstemp(suffix='.py')
+    # Create a new temp file
+    fd, temp_file_path = tempfile.mkstemp(suffix='.py')
     os.close(fd)
     
-    # Make sure launch parameters are correct
-    if "server_name" not in code or "server_port" not in code:
-        code += "\n\ndemo.launch(server_name='0.0.0.0', server_port=7861)\n"
+    # Write code to file
+    with open(temp_file_path, 'w') as f:
+        f.write(code)
     
-    # Remove any flagging parameters
-    code = code.replace("flagging_callback", "#flagging_callback")
-    code = code.replace("flagging_dir", "#flagging_dir")
+    # Run the app as a subprocess
+    app_process = subprocess.Popen([sys.executable, temp_file_path])
     
-    # Write the code to the file
-    with open(temp_file, 'w') as f:
-        f.write(code)
+    # Wait a moment for the app to start
+    time.sleep(3)
     
-    # Run the app
-    try:
-        running_process = subprocess.Popen(
-            [sys.executable, temp_file],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
-        
-        # Wait for the app to start
-        time.sleep(3)
-        
-        # Check if the process is still running
-        if running_process.poll() is not None:
-            stdout, stderr = running_process.communicate()
-            return False, f"App failed to start:\n{stderr.decode('utf-8')}"
-        
-        return True, None
-    except Exception as e:
-        return False, f"Error starting app: {str(e)}"
-
-# Create a minimal Gradio interface
-with gr.Blocks(title="Simple Gradio App Generator") as demo:
-    gr.Markdown("# 🤖 Gradio App Generator")
-    gr.Markdown("Enter a description of the app you want to create.")
+    # Check if process is still running
+    if app_process.poll() is not None:
+        return False, f"App failed to start (exit code: {app_process.returncode})"
     
-    api_key = gr.Textbox(
-        label="OpenAI API Key", 
-        placeholder="sk-...",
-        type="password"
-    )
+    return True, None
+
+# Create a very simple Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# 🤖 Simple Gradio App Generator")
     
-    prompt = gr.Textbox(
-        label="App Description", 
-        placeholder="Describe the Gradio app you want to create...",
-        lines=3
-    )
+    api_key = gr.Textbox(label="OpenAI API Key", placeholder="sk-...", type="password")
+    description = gr.Textbox(label="Describe the app you want", lines=3)
     
     with gr.Row():
-        generate_btn = gr.Button("Generate & Run App", variant="primary")
-        stop_btn = gr.Button("Stop App", variant="stop", visible=False)
+        generate_btn = gr.Button("Generate & Run App")
+        stop_btn = gr.Button("Stop Running App", visible=False)
     
-    code_output = gr.Code(
-        language="python",
-        label="Generated Code",
-        lines=10
-    )
+    code_display = gr.Code(label="Generated Code", language="python")
+    status = gr.Markdown("")
     
-    status_output = gr.Markdown("")
+    # Frame to display the running app
+    app_display = gr.HTML("<div style='text-align:center; margin-top:20px;'>App will appear here</div>")
     
-    app_frame = gr.HTML(
-        "<div style='text-align:center; padding:50px;'><h3>Your app will appear here</h3></div>"
-    )
-    
-    def on_generate(key, description):
-        """Generate and run the app"""
-        if not key or len(key) < 20 or not key.startswith("sk-"):
-            return (
-                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)
-            )
+    def generate_and_run(key, desc):
+        if not key or len(key) < 20:
+            return None, "Please enter a valid API key", gr.update(visible=False), gr.update(visible=False)
         
-        # Generate the code
-        code, error = call_openai_api(key, description)
-        if error or not code:
-            return (
-                None,
-                f"⚠️ Error: {error or 'Failed to generate code'}",
-                "<div style='text-align:center; padding:50px;'><h3>Error generating code</h3></div>",
-                gr.update(visible=False)
-            )
+        # Get code from API
+        code, error = get_app_code(key, desc)
+        if error:
+            return None, f"Error: {error}", gr.update(visible=False), gr.update(visible=False)
         
         # Run the app
-        success, run_error = run_app(code)
+        success, run_error = run_gradio_app(code)
         if not success:
-            return (
-                code,
-                f"⚠️ Error: {run_error}",
-                "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
-                gr.update(visible=False)
-            )
+            return code, f"Error running app: {run_error}", gr.update(visible=False), gr.update(visible=False)
         
-        # Create an iframe to display the app
-        iframe_html = f"""
-        <div style="height:600px; border:1px solid #ddd; border-radius:5px; overflow:hidden;">
+        # Create iframe to show the app
+        iframe = f"""
+        <div style="border:1px solid #ddd; border-radius:5px; height:500px; margin-top:10px;">
             <iframe src="http://localhost:7861" width="100%" height="100%" frameborder="0"></iframe>
         </div>
         """
         
-        return (
-            code,
-            "✅ App is running! View it below.",
-            iframe_html,
-            gr.update(visible=True)
-        )
+        return code, "✅ App is running! View it below:", iframe, gr.update(visible=True)
     
-    def on_stop():
-        """Stop the running app"""
-        global running_process, temp_file
+    def stop_app():
+        global app_process
         
-        if running_process and running_process.poll() is None:
-            running_process.terminate()
+        if app_process and app_process.poll() is None:
+            app_process.terminate()
             time.sleep(1)
-            if running_process.poll() is None:
-                running_process.kill()
+            if app_process.poll() is None:
+                app_process.kill()
         
-        if temp_file and os.path.exists(temp_file):
-            try:
-                os.unlink(temp_file)
-            except:
-                pass
-        
-        return (
-            "✅ App stopped",
-            "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
-            gr.update(visible=False)
-        )
+        return "App stopped", "<div style='text-align:center; margin-top:20px;'>App stopped</div>", gr.update(visible=False)
     
     generate_btn.click(
-        on_generate,
-        inputs=[api_key, prompt],
-        outputs=[code_output, status_output, app_frame, stop_btn]
+        generate_and_run,
+        inputs=[api_key, description],
+        outputs=[code_display, status, app_display, stop_btn]
     )
     
     stop_btn.click(
-        on_stop,
+        stop_app,
         inputs=[],
-        outputs=[status_output, app_frame, stop_btn]
+        outputs=[status, app_display, stop_btn]
     )
 
 if __name__ == "__main__":
-    # Launch with minimal parameters
     demo.launch(server_name="0.0.0.0", server_port=7860)