Update app.py

app.py

@@ -1,47 +1,137 @@
 import gradio as gr
-import tempfile
 import os
+import json
+import importlib
 import sys
-import subprocess
-import time
-import random
-import string
-import signal
-import atexit
+from contextlib import redirect_stdout, redirect_stderr
+import io
 
-# Set environment variable to avoid matplotlib issues
+# Set environment variable to avoid matplotlib permission issues
 os.environ['MPLCONFIGDIR'] = '/tmp'
 
-# Create a temp directory for our app files
-TEMP_DIR = os.path.join(tempfile.gettempdir(), "gradio_apps")
-os.makedirs(TEMP_DIR, exist_ok=True)
+# Toggle for different applications
+CURRENT_APP = "selector"
 
-# Track running processes
-running_process = None
-current_port = None
-current_file = None
+# Example app implementations
+APP_REGISTRY = {
+    "hello_world": {
+        "title": "Hello World",
+        "description": "A simple greeting app",
+        "function": None  # will be populated
+    },
+    "calculator": {
+        "title": "Calculator",
+        "description": "A basic arithmetic calculator",
+        "function": None  # will be populated
+    },
+    "image_filter": {
+        "title": "Image Filter",
+        "description": "Apply visual effects to images",
+        "function": None  # will be populated
+    }
+}
 
-# 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()
+# Hello World implementation
+def create_hello_world():
+    def greet(name):
+        return f"Hello, {name}!"
+    
+    demo = gr.Interface(
+        fn=greet,
+        inputs=gr.Textbox(label="Your Name"),
+        outputs=gr.Textbox(label="Greeting"),
+        title="Hello World App",
+        description="A simple greeting app",
+        examples=[["World"], ["Friend"], ["Gradio"]]
+    )
     
-    if current_file and os.path.exists(current_file):
-        try:
-            os.unlink(current_file)
-        except:
-            pass
+    return demo
 
-# Register cleanup
-atexit.register(cleanup)
+# Calculator implementation
+def create_calculator():
+    def calculate(num1, num2, operation):
+        if operation == "Add":
+            return num1 + num2
+        elif operation == "Subtract":
+            return num1 - num2
+        elif operation == "Multiply":
+            return num1 * num2
+        elif operation == "Divide":
+            if num2 == 0:
+                return "Error: Division by zero"
+            return num1 / num2
+    
+    demo = gr.Interface(
+        fn=calculate,
+        inputs=[
+            gr.Number(label="First Number"),
+            gr.Number(label="Second Number"),
+            gr.Radio(["Add", "Subtract", "Multiply", "Divide"], label="Operation")
+        ],
+        outputs=gr.Textbox(label="Result"),
+        title="Calculator App",
+        description="Perform basic arithmetic operations",
+        examples=[
+            [5, 3, "Add"],
+            [10, 4, "Subtract"],
+            [6, 7, "Multiply"],
+            [20, 4, "Divide"]
+        ]
+    )
+    
+    return demo
 
-# Example Gradio app codes to choose from
-EXAMPLE_APPS = {
+# Image Filter implementation
+def create_image_filter():
+    def apply_filter(image, filter_type):
+        if image is None:
+            return None
+        
+        import numpy as np
+        from PIL import Image
+        
+        img_array = np.array(image)
+        
+        if filter_type == "Grayscale":
+            result = np.mean(img_array, axis=2).astype(np.uint8)
+            return Image.fromarray(result)
+        elif filter_type == "Invert":
+            result = 255 - img_array
+            return Image.fromarray(result)
+        elif filter_type == "Sepia":
+            sepia = np.array([[0.393, 0.769, 0.189],
+                             [0.349, 0.686, 0.168],
+                             [0.272, 0.534, 0.131]])
+            sepia_img = img_array.dot(sepia.T)
+            sepia_img[sepia_img > 255] = 255
+            return Image.fromarray(sepia_img.astype(np.uint8))
+        return image
+    
+    demo = gr.Interface(
+        fn=apply_filter,
+        inputs=[
+            gr.Image(type="pil"),
+            gr.Radio(["Grayscale", "Invert", "Sepia"], label="Filter")
+        ],
+        outputs=gr.Image(type="pil"),
+        title="Image Filter App",
+        description="Apply different filters to your images",
+        examples=[
+            ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Grayscale"],
+            ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Invert"],
+            ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Sepia"]
+        ]
+    )
+    
+    return demo
+
+# Register demo creation functions
+APP_REGISTRY["hello_world"]["function"] = create_hello_world
+APP_REGISTRY["calculator"]["function"] = create_calculator
+APP_REGISTRY["image_filter"]["function"] = create_image_filter
+
+# Example of code for each app as a string (for display purposes)
+APP_CODES = {
     "hello_world": """
 import gradio as gr
 
@@ -53,11 +143,9 @@ demo = gr.Interface(
     inputs=gr.Textbox(label="Your Name"),
     outputs=gr.Textbox(label="Greeting"),
     title="Hello World App",
-    description="A simple greeting app"
+    description="A simple greeting app",
+    examples=[["World"], ["Friend"], ["Gradio"]]
 )
-
-# Launch on specified port
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
 
     "calculator": """
@@ -84,11 +172,14 @@ demo = gr.Interface(
     ],
     outputs=gr.Textbox(label="Result"),
     title="Calculator App",
-    description="Perform basic arithmetic operations"
+    description="Perform basic arithmetic operations",
+    examples=[
+        [5, 3, "Add"],
+        [10, 4, "Subtract"],
+        [6, 7, "Multiply"],
+        [20, 4, "Divide"]
+    ]
 )
-
-# Launch on specified port
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
 
     "image_filter": """
@@ -125,208 +216,152 @@ demo = gr.Interface(
     ],
     outputs=gr.Image(type="pil"),
     title="Image Filter App",
-    description="Apply different filters to your images"
+    description="Apply different filters to your images",
+    examples=[
+        ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Grayscale"],
+        ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Invert"],
+        ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=500", "Sepia"]
+    ]
 )
-
-# Launch on specified port
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """
 }
 
-# Function to find an available port
-def find_available_port(start=7870):
-    import socket
-    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_app(app_code, port):
-    global running_process, current_file
-    
-    # Stop any existing app
-    stop_app()
-    
-    # Replace PORT in the code
-    app_code = app_code.replace("PORT", str(port))
-    
-    # Create a temporary file
-    fd, filepath = tempfile.mkstemp(suffix='.py', dir=TEMP_DIR)
-    os.close(fd)
-    
-    with open(filepath, 'w') as f:
-        f.write(app_code)
-    
-    # Store the current file path
-    current_file = filepath
-    
-    # Run the app
-    try:
-        process = subprocess.Popen(
-            [sys.executable, filepath],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+# Function to create the selector app
+def create_selector():
+    with gr.Blocks(title="Gradio App Generator") as demo:
+        gr.Markdown("# 🔄 Dynamic Gradio App Generator")
+        gr.Markdown("Select an app type to load it, or use the LLM to generate one")
         
-        # Store the process
-        running_process = process
+        with gr.Row():
+            with gr.Column(scale=1):
+                # App selection area
+                gr.Markdown("### 1. Choose an App Template")
+                app_selection = gr.Radio(
+                    choices=list(APP_REGISTRY.keys()),
+                    value="hello_world",
+                    label="Available Templates",
+                    info="Select a template to view and run it",
+                    interactive=True
+                )
+                
+                # Description display
+                app_description = gr.Markdown(f"**{APP_REGISTRY['hello_world']['title']}**: {APP_REGISTRY['hello_world']['description']}")
+                
+                # Load button
+                load_btn = gr.Button("Load Selected App", variant="primary")
+                
+                # Code display
+                with gr.Accordion("View Code", open=False):
+                    code_display = gr.Code(
+                        language="python",
+                        value=APP_CODES["hello_world"],
+                        label="App Code"
+                    )
+                
+                # Status message
+                status_msg = gr.Markdown("Select an app and click 'Load Selected App'")
+                
+                # Simulated LLM area
+                gr.Markdown("### 2. Or Describe a New App")
+                
+                app_description_input = gr.Textbox(
+                    label="Describe the app you want",
+                    placeholder="e.g., A calculator app that can add, subtract, multiply and divide",
+                    lines=3
+                )
+                
+                generate_btn = gr.Button("Generate & Load App")
+            
+            with gr.Column(scale=1):
+                # Preview placeholder
+                preview_box = gr.Markdown(
+                    """
+                    ### App Preview
+                    
+                    No app loaded yet. Select an app template or describe a new app to load.
+                    """
+                )
         
-        # Wait a moment for the app to start
-        time.sleep(2)
+        # Update description when selection changes
+        def update_description_and_code(selection):
+            return f"**{APP_REGISTRY[selection]['title']}**: {APP_REGISTRY[selection]['description']}", APP_CODES[selection]
         
-        # Check if the process is still running
-        if process.poll() is not None:
-            # Process failed to start
-            stdout, stderr = process.communicate()
-            error_msg = f"App failed to start: {stderr.decode('utf-8')}"
-            return None, error_msg
+        app_selection.change(
+            update_description_and_code,
+            inputs=app_selection,
+            outputs=[app_description, code_display]
+        )
         
-        return port, None
-    except Exception as e:
-        return None, f"Error starting app: {str(e)}"
-
-# Function to stop the running app
-def stop_app():
-    global running_process, current_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(current_file)
-        except:
-            pass
-    
-    running_process = None
-    current_file = None
-
-# 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="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():
-        with gr.Column(scale=1):
-            # 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"
-            )
+        # Function to load the selected app
+        def load_app(app_name):
+            # Save the app name to a file so it persists
+            with open("current_app.txt", "w") as f:
+                f.write(app_name)
             
-            # Example buttons
-            with gr.Row():
-                hello_btn = gr.Button("Hello World")
-                calc_btn = gr.Button("Calculator")
-                image_btn = gr.Button("Image Filter")
+            return f"Loading {APP_REGISTRY[app_name]['title']}... Refresh the page to see it."
+        
+        load_btn.click(
+            load_app,
+            inputs=app_selection,
+            outputs=status_msg
+        )
+        
+        # Function to handle app generation from description
+        def generate_app(description):
+            if not description:
+                return "Please enter a description first."
             
-            # Generate and stop buttons
-            with gr.Row():
-                generate_btn = gr.Button("Generate & Run App", variant="primary")
-                stop_btn = gr.Button("Stop App", variant="stop")
+            # Simple keyword matching to choose an app
+            description = description.lower()
             
-            # Code display
-            with gr.Accordion("Generated Code", open=False):
-                code_display = gr.Code(language="python")
+            if "hello" in description or "greet" in description:
+                app_name = "hello_world"
+            elif "calculat" in description or "math" in description or "add" in description:
+                app_name = "calculator"
+            elif "image" in description or "filter" in description or "photo" in description:
+                app_name = "image_filter"
+            else:
+                # Default to hello world
+                app_name = "hello_world"
             
-            # Status message
-            status_msg = gr.Markdown("")
-        
-        with gr.Column(scale=2):
-            # 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 handlers
-    def set_description(desc):
-        return desc
-    
-    hello_btn.click(
-        lambda: set_description("A hello world app that greets the user by name"),
-        inputs=None,
-        outputs=app_description
-    )
-    
-    calc_btn.click(
-        lambda: set_description("A calculator app that performs basic arithmetic"),
-        inputs=None,
-        outputs=app_description
-    )
-    
-    image_btn.click(
-        lambda: set_description("An image filter app that can apply effects to photos"),
-        inputs=None,
-        outputs=app_description
-    )
-    
-    # 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>"
-        
-        # Select app based on description
-        app_code = select_app(description)
-        
-        # Find an available port
-        port = find_available_port()
-        
-        # Run the app
-        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 iframe to show the app
-        iframe_html = f"""
-        <div style="border:1px solid #ddd; height:500px; overflow:hidden;">
-            <iframe src="http://localhost:{result_port}" width="100%" height="100%" frameborder="0"></iframe>
-        </div>
-        """
+            # Save the app name to a file
+            with open("current_app.txt", "w") as f:
+                f.write(app_name)
+            
+            return f"Generated and loading {APP_REGISTRY[app_name]['title']}... Refresh the page to see it."
         
-        return app_code, f"✅ App running on port {result_port}", iframe_html
-    
-    # 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 buttons to handlers
-    generate_btn.click(
-        on_generate,
-        inputs=app_description,
-        outputs=[code_display, status_msg, app_frame]
-    )
+        generate_btn.click(
+            generate_app,
+            inputs=app_description_input,
+            outputs=status_msg
+        )
     
-    stop_btn.click(
-        on_stop,
-        inputs=None,
-        outputs=[status_msg, app_frame]
-    )
+    return demo
+
+# Check which app to load
+if os.path.exists("current_app.txt"):
+    try:
+        with open("current_app.txt", "r") as f:
+            app_name = f.read().strip()
+            if app_name in APP_REGISTRY:
+                CURRENT_APP = app_name
+            else:
+                CURRENT_APP = "selector"
+    except:
+        CURRENT_APP = "selector"
+
+# Launch the appropriate app
+if CURRENT_APP == "selector":
+    demo = create_selector()
+else:
+    try:
+        # Try to create the requested app
+        demo = APP_REGISTRY[CURRENT_APP]["function"]()
+    except Exception as e:
+        # Fall back to selector on error
+        print(f"Error loading app {CURRENT_APP}: {str(e)}")
+        demo = create_selector()
 
-# Launch the main app
+# Launch the app
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)