Update app.py

app.py

@@ -1,26 +1,47 @@
 import gradio as gr
-import os
 import tempfile
-import time
+import os
+import sys
 import subprocess
-import threading
-import signal
-import json
+import time
 import random
 import string
+import signal
+import atexit
 
-# Set fixed MPLCONFIGDIR to avoid permission issues
+# Set environment variable to avoid matplotlib issues
 os.environ['MPLCONFIGDIR'] = '/tmp'
 
-# Create tmp directory if it doesn't exist
+# Create a temp directory for our app files
 TEMP_DIR = os.path.join(tempfile.gettempdir(), "gradio_apps")
 os.makedirs(TEMP_DIR, exist_ok=True)
 
 # Track running processes
-processes = {}
+running_process = None
+current_port = None
+current_file = None
 
-# Sample code for different Gradio apps
-EXAMPLE_CODES = {
+# Cleanup function to ensure we don't leave processes running
+def cleanup():
+    global running_process, current_file
+    if running_process and running_process.poll() is None:
+        try:
+            running_process.terminate()
+            running_process.wait(timeout=5)
+        except:
+            running_process.kill()
+    
+    if current_file and os.path.exists(current_file):
+        try:
+            os.unlink(current_file)
+        except:
+            pass
+
+# Register cleanup
+atexit.register(cleanup)
+
+# Example Gradio app codes to choose from
+EXAMPLE_APPS = {
     "hello_world": """
 import gradio as gr
 
@@ -31,13 +52,14 @@ demo = gr.Interface(
     fn=greet,
     inputs=gr.Textbox(label="Your Name"),
     outputs=gr.Textbox(label="Greeting"),
-    title="Hello World",
+    title="Hello World App",
     description="A simple greeting app"
 )
 
+# Launch on specified port
 demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
-    
+
     "calculator": """
 import gradio as gr
 
@@ -61,13 +83,14 @@ demo = gr.Interface(
         gr.Radio(["Add", "Subtract", "Multiply", "Divide"], label="Operation")
     ],
     outputs=gr.Textbox(label="Result"),
-    title="Calculator",
+    title="Calculator App",
     description="Perform basic arithmetic operations"
 )
 
+# Launch on specified port
 demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
-    
+
     "image_filter": """
 import gradio as gr
 import numpy as np
@@ -101,290 +124,207 @@ demo = gr.Interface(
         gr.Radio(["Grayscale", "Invert", "Sepia"], label="Filter")
     ],
     outputs=gr.Image(type="pil"),
-    title="Image Filter",
-    description="Apply various filters to images",
-    allow_flagging=False
+    title="Image Filter App",
+    description="Apply different filters to your images"
 )
 
+# Launch on specified port
 demo.launch(server_name="0.0.0.0", server_port=PORT)
 """
 }
 
-# Function to simulate LLM API call
-def simulate_llm_response(prompt):
-    """Simulate an LLM response based on the prompt"""
-    prompt_lower = prompt.lower()
-    
-    if "hello" in prompt_lower or "greet" in prompt_lower:
-        return EXAMPLE_CODES["hello_world"], None
-    elif "calculat" in prompt_lower or "math" in prompt_lower or "arithmetic" in prompt_lower:
-        return EXAMPLE_CODES["calculator"], None
-    elif "image" in prompt_lower or "filter" in prompt_lower or "photo" in prompt_lower:
-        return EXAMPLE_CODES["image_filter"], None
-    else:
-        # Default to hello world
-        return EXAMPLE_CODES["hello_world"], None
-
-# Find an available port
-def find_available_port(start_port=7870):
-    """Find an available port starting from start_port"""
+# Function to find an available port
+def find_available_port(start=7870):
     import socket
-    from contextlib import closing
-    
-    def is_port_available(port):
-        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
-            return sock.connect_ex(('localhost', port)) != 0
-    
-    port = start_port
-    while not is_port_available(port):
-        port += 1
-    
-    return port
-
-# Generate a random string
-def random_string(length=8):
-    """Generate a random string of fixed length"""
-    letters = string.ascii_lowercase
-    return ''.join(random.choice(letters) for i in range(length))
+    port = start
+    while True:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(('localhost', port))
+                return port
+        except OSError:
+            port += 1
 
 # Function to run a Gradio app as a subprocess
-def run_gradio_app(code, app_id=None):
-    """Run a Gradio app as a subprocess and return the port"""
-    global processes
+def run_app(app_code, port):
+    global running_process, current_file
     
-    # Clean up any previous process with the same ID
-    if app_id in processes and processes[app_id]["process"].poll() is None:
-        processes[app_id]["process"].terminate()
-        try:
-            processes[app_id]["process"].wait(timeout=5)
-        except:
-            processes[app_id]["process"].kill()
-        
-        # Remove the file
-        try:
-            os.unlink(processes[app_id]["file"])
-        except:
-            pass
+    # Stop any existing app
+    stop_app()
     
-    # Generate a unique ID if not provided
-    if app_id is None:
-        app_id = random_string()
+    # Replace PORT in the code
+    app_code = app_code.replace("PORT", str(port))
     
-    # Find an available port
-    port = find_available_port()
+    # Create a temporary file
+    fd, filepath = tempfile.mkstemp(suffix='.py', dir=TEMP_DIR)
+    os.close(fd)
     
-    # Replace PORT in the code with the actual port
-    code = code.replace("PORT", str(port))
+    with open(filepath, 'w') as f:
+        f.write(app_code)
     
-    # Create a temporary file
-    with tempfile.NamedTemporaryFile(suffix='.py', dir=TEMP_DIR, delete=False) as f:
-        f.write(code.encode('utf-8'))
-        file_path = f.name
+    # Store the current file path
+    current_file = filepath
     
-    # Run the app as a subprocess
+    # Run the app
     try:
         process = subprocess.Popen(
-            [sys.executable, file_path],
+            [sys.executable, filepath],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE
         )
         
+        # Store the process
+        running_process = process
+        
         # Wait a moment for the app to start
-        time.sleep(3)
+        time.sleep(2)
         
         # Check if the process is still running
         if process.poll() is not None:
+            # Process failed to start
             stdout, stderr = process.communicate()
-            return None, f"App failed to start (exit code: {process.returncode})\nStdout: {stdout.decode('utf-8')}\nStderr: {stderr.decode('utf-8')}"
-        
-        # Store the process and file path
-        processes[app_id] = {
-            "process": process,
-            "file": file_path,
-            "port": port
-        }
+            error_msg = f"App failed to start: {stderr.decode('utf-8')}"
+            return None, error_msg
         
         return port, None
     except Exception as e:
-        import traceback
-        return None, f"Error starting app: {str(e)}\n{traceback.format_exc()}"
+        return None, f"Error starting app: {str(e)}"
 
-# Function to stop a running app
-def stop_gradio_app(app_id):
-    """Stop a running Gradio app"""
-    global processes
+# Function to stop the running app
+def stop_app():
+    global running_process, current_file
     
-    if app_id in processes:
-        process = processes[app_id]["process"]
-        file_path = processes[app_id]["file"]
-        
-        if process.poll() is None:
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except:
-                process.kill()
-        
-        # Remove the file
+    if running_process and running_process.poll() is None:
+        running_process.terminate()
+        try:
+            running_process.wait(timeout=5)
+        except:
+            running_process.kill()
+    
+    if current_file and os.path.exists(current_file):
         try:
-            os.unlink(file_path)
+            os.unlink(current_file)
         except:
             pass
-        
-        del processes[app_id]
-        return True
     
-    return False
-
-# Clean up on exit
-def cleanup():
-    """Clean up all running processes and temporary files"""
-    for app_id in list(processes.keys()):
-        stop_gradio_app(app_id)
+    running_process = None
+    current_file = None
 
-import atexit
-atexit.register(cleanup)
-
-# Import sys after we've defined all the functions
-import sys
+# Function to select an app based on description
+def select_app(description):
+    description = description.lower()
+    
+    if "hello" in description or "greet" in description:
+        return EXAMPLE_APPS["hello_world"]
+    elif "calculat" in description or "math" in description or "arithmetic" in description:
+        return EXAMPLE_APPS["calculator"]
+    elif "image" in description or "filter" in description or "photo" in description:
+        return EXAMPLE_APPS["image_filter"]
+    else:
+        # Default to hello world
+        return EXAMPLE_APPS["hello_world"]
 
 # Main Gradio interface
-with gr.Blocks(title="LLM Gradio App Generator") as demo:
-    # Header
-    gr.Markdown("# 🤖 LLM Gradio App Generator")
-    gr.Markdown("Generate and run Gradio apps dynamically!")
-    
-    # App ID for tracking the current app
-    app_id = gr.State("")
+with gr.Blocks(title="Gradio App Generator") as demo:
+    gr.Markdown("# 🔄 Dynamic Gradio App Generator")
+    gr.Markdown("Select an app type to generate and run it dynamically")
     
     with gr.Row():
-        # Left column (input)
         with gr.Column(scale=1):
-            # App description input
-            prompt = gr.Textbox(
-                label="Describe the app you want",
-                placeholder="e.g., A calculator app that can perform basic arithmetic",
-                lines=3
+            # Input area
+            app_description = gr.Textbox(
+                label="App Description",
+                placeholder="Describe the app you want to generate...",
+                lines=3,
+                value="A calculator app that performs basic arithmetic"
             )
             
             # Example buttons
-            gr.Markdown("### Try These Examples:")
             with gr.Row():
                 hello_btn = gr.Button("Hello World")
                 calc_btn = gr.Button("Calculator")
                 image_btn = gr.Button("Image Filter")
             
-            # Generate button
+            # Generate and stop buttons
             with gr.Row():
                 generate_btn = gr.Button("Generate & Run App", variant="primary")
                 stop_btn = gr.Button("Stop App", variant="stop")
             
-            # Display the generated code
+            # Code display
             with gr.Accordion("Generated Code", open=False):
-                code_output = gr.Code(language="python", label="Python Code")
+                code_display = gr.Code(language="python")
             
             # Status message
-            status_output = gr.Markdown("Enter a description and click 'Generate & Run App'")
+            status_msg = gr.Markdown("")
         
-        # Right column (output)
         with gr.Column(scale=2):
-            # Frame to display the running app
-            app_frame = gr.HTML(
-                """<div style="display:flex; justify-content:center; align-items:center; height:600px; border:1px dashed #ccc; border-radius:8px;">
-                    <div style="text-align:center;">
-                        <h3>App Preview</h3>
-                        <p>Generate an app to see it here</p>
-                    </div>
-                </div>"""
-            )
+            # Preview area
+            app_frame = gr.HTML("<div style='border:1px dashed #ccc; height:500px; display:flex; justify-content:center; align-items:center;'><p>App will appear here</p></div>")
     
-    # Example button functions
-    def use_example(example_text):
-        return example_text
+    # Example button handlers
+    def set_description(desc):
+        return desc
     
     hello_btn.click(
-        lambda: use_example("A simple hello world app that greets the user by name"),
+        lambda: set_description("A hello world app that greets the user by name"),
         inputs=None,
-        outputs=prompt
+        outputs=app_description
     )
     
     calc_btn.click(
-        lambda: use_example("A calculator app that can add, subtract, multiply and divide two numbers"),
+        lambda: set_description("A calculator app that performs basic arithmetic"),
         inputs=None,
-        outputs=prompt
+        outputs=app_description
     )
     
     image_btn.click(
-        lambda: use_example("An image filter app that can apply grayscale, invert, and sepia filters to images"),
+        lambda: set_description("An image filter app that can apply effects to photos"),
         inputs=None,
-        outputs=prompt
+        outputs=app_description
     )
     
-    # Generate and run the app
-    def on_generate_click(prompt_text, current_app_id):
-        if not prompt_text:
-            return current_app_id, "", "Please enter a description of the app you want to generate.", app_frame.value
+    # Generate button handler
+    def on_generate(description):
+        if not description:
+            return None, "Please enter a description", "<div style='border:1px dashed #ccc; height:500px; display:flex; justify-content:center; align-items:center;'><p>Enter a description first</p></div>"
         
-        # Stop the current app if running
-        if current_app_id:
-            stop_gradio_app(current_app_id)
+        # Select app based on description
+        app_code = select_app(description)
         
-        # Generate a new app ID
-        new_app_id = random_string()
-        
-        # Get code from LLM (simulated)
-        code, error = simulate_llm_response(prompt_text)
-        if error:
-            return current_app_id, "", f"Error generating code: {error}", app_frame.value
+        # Find an available port
+        port = find_available_port()
         
         # Run the app
-        port, run_error = run_gradio_app(code, new_app_id)
-        if run_error:
-            return current_app_id, code, f"Error running app: {run_error}", app_frame.value
+        result_port, error = run_app(app_code, port)
+        
+        if error:
+            return app_code, f"Error: {error}", "<div style='border:1px solid #f44336; height:500px; display:flex; justify-content:center; align-items:center;'><p>Failed to start app:<br>{error}</p></div>"
         
-        # Create an iframe to display the app
+        # Create iframe to show the app
         iframe_html = f"""
-        <div style="height:600px; border:1px solid #ddd; border-radius:8px; overflow:hidden;">
-            <iframe src="http://localhost:{port}" width="100%" height="100%" frameborder="0"></iframe>
+        <div style="border:1px solid #ddd; height:500px; overflow:hidden;">
+            <iframe src="http://localhost:{result_port}" width="100%" height="100%" frameborder="0"></iframe>
         </div>
         """
         
-        return new_app_id, code, f"✅ App running on port {port}", iframe_html
+        return app_code, f"✅ App running on port {result_port}", iframe_html
     
-    # Stop the app
-    def on_stop_click(current_app_id):
-        if not current_app_id:
-            return "", "No app is currently running"
-        
-        stopped = stop_gradio_app(current_app_id)
-        
-        if stopped:
-            # Reset the frame
-            iframe_html = """
-            <div style="display:flex; justify-content:center; align-items:center; height:600px; border:1px dashed #ccc; border-radius:8px;">
-                <div style="text-align:center;">
-                    <h3>App Stopped</h3>
-                    <p>Generate a new app to see it here</p>
-                </div>
-            </div>
-            """
-            
-            return "", f"✅ App stopped successfully", iframe_html
-        else:
-            return current_app_id, "Failed to stop the app", app_frame.value
+    # Stop button handler
+    def on_stop():
+        stop_app()
+        return "✅ App stopped", "<div style='border:1px dashed #ccc; height:500px; display:flex; justify-content:center; align-items:center;'><p>App stopped</p></div>"
     
-    # Connect the generate button
+    # Connect buttons to handlers
     generate_btn.click(
-        on_generate_click,
-        inputs=[prompt, app_id],
-        outputs=[app_id, code_output, status_output, app_frame]
+        on_generate,
+        inputs=app_description,
+        outputs=[code_display, status_msg, app_frame]
     )
     
-    # Connect the stop button
     stop_btn.click(
-        on_stop_click,
-        inputs=[app_id],
-        outputs=[app_id, status_output, app_frame]
+        on_stop,
+        inputs=None,
+        outputs=[status_msg, app_frame]
     )
 
 # Launch the main app