Update app.py

app.py

@@ -1,163 +1,43 @@
 import streamlit as st
 import gradio as gr
-import subprocess
+import importlib.util
+import sys
 import tempfile
 import os
-import time
-import signal
-import requests
-import re
-import json
-import sys
 from pathlib import Path
-import atexit
+import inspect
+import types
+import shutil
+import uuid
 
-# Print version info
+# Configure the Streamlit page
 st.set_page_config(
-    page_title="Gradio App Generator",
-    page_icon="🤖",
+    page_title="Gradio Examples Hub",
+    page_icon="🧩",
     layout="wide"
 )
 
-# Directory to store temporary apps
-TEMP_DIR = Path(tempfile.gettempdir()) / "gradio_apps"
-os.makedirs(TEMP_DIR, exist_ok=True)
-
-# Track running processes
-if 'process' not in st.session_state:
-    st.session_state.process = None
-    st.session_state.app_port = None
-    st.session_state.app_path = None
-
-# Clean up on exit
-def cleanup():
-    if st.session_state.process and st.session_state.process.poll() is None:
-        st.session_state.process.terminate()
-        try:
-            st.session_state.process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            st.session_state.process.kill()
-    
-    # Clean up temp files
-    if st.session_state.app_path and os.path.exists(st.session_state.app_path):
-        try:
-            os.unlink(st.session_state.app_path)
-        except:
-            pass
+# Directory structure
+EXAMPLES_DIR = Path("gradio_examples")
+EXAMPLES_DIR.mkdir(exist_ok=True)
 
-atexit.register(cleanup)
+# Make sure we have a __init__.py file in the examples directory
+init_file = EXAMPLES_DIR / "__init__.py"
+if not init_file.exists():
+    init_file.touch()
 
-def stop_running_app():
-    """Stop the currently running Gradio app"""
-    if st.session_state.process and st.session_state.process.poll() is None:
-        st.session_state.process.terminate()
-        try:
-            st.session_state.process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            st.session_state.process.kill()
-        
-        st.session_state.process = None
-        st.session_state.app_port = None
-        
-        if st.session_state.app_path and os.path.exists(st.session_state.app_path):
-            try:
-                os.unlink(st.session_state.app_path)
-            except:
-                pass
-            st.session_state.app_path = None
-        
-        return True
-    
-    return False
-
-def get_openai_code(api_key, description):
-    """Get code from OpenAI API"""
-    prompt = f"""Create a simple Gradio app that {description}.
-    
-    IMPORTANT: The app should:
-    1. Use gr.Interface (not Blocks) 
-    2. Have flagging_callback=None to avoid permission issues
-    3. Include demo.launch(server_name="0.0.0.0", server_port=PORT) at the end
-    4. Be self-contained with only standard libraries
-    
-    Provide ONLY Python code with no explanation."""
-    
-    try:
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {api_key}"
-            },
-            json={
-                "model": "gpt-4o",
-                "messages": [
-                    {"role": "system", "content": "You are a Gradio expert. Provide only Python code without explanations."},
-                    {"role": "user", "content": prompt}
-                ],
-                "temperature": 0.2
-            },
-            timeout=30
-        )
-        
-        if response.status_code != 200:
-            return None, f"API Error: {response.status_code}"
-        
-        content = response.json()["choices"][0]["message"]["content"]
-        
-        # Extract code blocks if present
-        code_pattern = r'```python\s*([\s\S]*?)```'
-        code_matches = re.findall(code_pattern, content)
-        
-        if code_matches:
-            return code_matches[0], None
-        
-        # If no code blocks found, use the whole content
-        return content, None
-    
-    except Exception as e:
-        return None, f"Error: {str(e)}"
+# Ensure the examples directory is in the Python path
+if str(EXAMPLES_DIR.absolute()) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR.absolute()))
 
-def run_gradio_app(code, port=8050):
-    """Run a Gradio app with the given code"""
-    # Stop any existing app
-    stop_running_app()
-    
-    # Replace PORT in the code with the actual port
-    code = code.replace("PORT", str(port))
-    
-    # Make sure flagging is disabled
-    if "gr.Interface" in code and "flagging_callback=None" not in code:
-        code = code.replace("gr.Interface(", "gr.Interface(flagging_callback=None, ")
-    
-    # Create a temporary file
-    fd, path = tempfile.mkstemp(suffix='.py', dir=TEMP_DIR)
-    with os.fdopen(fd, 'w') as f:
-        f.write(code)
-    
-    st.session_state.app_path = path
-    
-    # Run the app as a subprocess
-    try:
-        process = subprocess.Popen([sys.executable, path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        st.session_state.process = process
-        st.session_state.app_port = port
-        
-        # Wait a bit for the app to start
-        time.sleep(3)
-        
-        # Check if process is still running
-        if process.poll() is not None:
-            stdout, stderr = process.communicate()
-            return False, f"Failed to start app: {stderr.decode('utf-8')}"
-        
-        return True, None
-    
-    except Exception as e:
-        return False, f"Error starting app: {str(e)}"
+# Create session state for tracking the current app
+if 'current_app' not in st.session_state:
+    st.session_state.current_app = None
+    st.session_state.current_app_module = None
+    st.session_state.app_interface = None
 
-# Predefined Gradio app templates
-TEMPLATES = {
+# Example Gradio apps as Python code
+EXAMPLES = {
     "hello_world": """
 import gradio as gr
 
@@ -166,17 +46,17 @@ def greet(name):
 
 demo = gr.Interface(
     fn=greet,
-    inputs=gr.Textbox(label="Name"),
+    inputs=gr.Textbox(label="Your Name", placeholder="Enter your name"),
     outputs=gr.Textbox(label="Greeting"),
     title="Hello World App",
-    flagging_callback=None
+    description="A simple app that greets you by name",
+    examples=[["World"], ["Gradio"], ["Streamlit"]]
 )
-
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
 
     "calculator": """
 import gradio as gr
+import numpy as np
 
 def calculate(num1, num2, operation):
     if operation == "Add":
@@ -199,45 +79,52 @@ demo = gr.Interface(
     ],
     outputs=gr.Textbox(label="Result"),
     title="Simple Calculator",
-    flagging_callback=None
+    description="Perform basic arithmetic operations",
+    examples=[
+        [5, 3, "Add"],
+        [10, 4, "Subtract"],
+        [6, 7, "Multiply"],
+        [20, 4, "Divide"]
+    ]
 )
-
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
 
     "image_filter": """
 import gradio as gr
 import numpy as np
+from PIL import Image
 
 def apply_filter(image, filter_type):
     if image is None:
         return None
         
+    img_array = np.array(image)
+    
     if filter_type == "Grayscale":
-        return np.mean(image, axis=2).astype(np.uint8)
+        result = np.mean(img_array, axis=2).astype(np.uint8)
+        return Image.fromarray(result)
     elif filter_type == "Invert":
-        return 255 - image
+        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 = image.dot(sepia.T)
+        sepia_img = img_array.dot(sepia.T)
         sepia_img[sepia_img > 255] = 255
-        return sepia_img.astype(np.uint8)
+        return Image.fromarray(sepia_img.astype(np.uint8))
     return image
 
 demo = gr.Interface(
     fn=apply_filter,
     inputs=[
-        gr.Image(type="numpy"),
+        gr.Image(type="pil"),
         gr.Radio(["Grayscale", "Invert", "Sepia"], label="Filter")
     ],
-    outputs=gr.Image(type="numpy"),
+    outputs=gr.Image(type="pil"),
     title="Image Filter App",
-    flagging_callback=None
+    description="Apply various filters to your images"
 )
-
-demo.launch(server_name="0.0.0.0", server_port=PORT)
 """,
 
     "text_analysis": """
@@ -258,86 +145,239 @@ demo = gr.Interface(
     inputs=gr.Textbox(label="Enter Text", lines=5),
     outputs=gr.Textbox(label="Analysis"),
     title="Text Analysis Tool",
-    flagging_callback=None
+    description="Count characters, words, and lines in text",
+    examples=[
+        ["Hello, world!"],
+        ["This is an example.\\nIt has multiple lines.\\nThree lines in total."],
+        ["The quick brown fox jumps over the lazy dog."]
+    ]
+)
+""",
+
+    "chatbot": """
+import gradio as gr
+
+def respond(message, history):
+    # Simple echo bot for demonstration
+    return f"You said: {message}"
+
+demo = gr.ChatInterface(
+    fn=respond,
+    title="Echo Bot",
+    description="A simple chatbot that echoes your messages",
+    examples=["Hello", "What's your name?", "Tell me a joke"]
 )
+""",
+
+    "audio_player": """
+import gradio as gr
+import numpy as np
+
+def generate_tone(frequency, duration):
+    sr = 44100  # Sample rate
+    t = np.linspace(0, duration, int(sr * duration), False)
+    tone = 0.5 * np.sin(2 * np.pi * frequency * t)
+    return sr, tone
 
-demo.launch(server_name="0.0.0.0", server_port=PORT)
+demo = gr.Interface(
+    fn=generate_tone,
+    inputs=[
+        gr.Slider(110, 880, 440, label="Frequency (Hz)"),
+        gr.Slider(0.1, 5, 1, label="Duration (seconds)")
+    ],
+    outputs=gr.Audio(type="numpy"),
+    title="Tone Generator",
+    description="Generate a sine wave tone with the specified frequency and duration"
+)
 """
 }
 
-# Streamlit UI
-st.title("🤖 Gradio App Generator")
-
-tab1, tab2 = st.tabs(["Built-in Templates", "Custom Generator"])
+def load_example(example_name):
+    """Load a Gradio example from the examples directory or create it if it doesn't exist"""
+    # Generate a unique module name to avoid caching issues
+    module_name = f"gradio_examples.{example_name}_{uuid.uuid4().hex[:8]}"
+    file_path = EXAMPLES_DIR / f"{module_name.split('.')[-1]}.py"
+    
+    # Write the example code to a file
+    with open(file_path, "w") as f:
+        f.write(EXAMPLES[example_name])
+    
+    # Import the module
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    
+    # Return the module and Gradio demo
+    return module, module.demo
 
-# Built-in templates tab
-with tab1:
-    st.header("Generate from Templates")
+def create_custom_example(code):
+    """Create a custom Gradio example from code"""
+    # Generate a unique module name
+    module_name = f"gradio_examples.custom_{uuid.uuid4().hex[:8]}"
+    file_path = EXAMPLES_DIR / f"{module_name.split('.')[-1]}.py"
     
-    template_choice = st.selectbox(
-        "Select a template",
-        ["hello_world", "calculator", "image_filter", "text_analysis"],
-        format_func=lambda x: {
-            "hello_world": "Hello World",
-            "calculator": "Simple Calculator",
-            "image_filter": "Image Filter",
-            "text_analysis": "Text Analysis"
-        }[x]
-    )
+    # Write the code to a file
+    with open(file_path, "w") as f:
+        f.write(code)
     
-    if st.button("Generate from Template"):
-        code = TEMPLATES[template_choice]
-        success, error = run_gradio_app(code)
+    # Import the module
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
         
-        if success:
-            st.success("App started successfully!")
+        # Check if the module has a demo attribute
+        if hasattr(module, 'demo'):
+            return module, module.demo, None
         else:
-            st.error(f"Failed to start app: {error}")
+            return None, None, "No 'demo' variable found in the code"
+    except Exception as e:
+        return None, None, f"Error loading code: {str(e)}"
+
+def stop_current_app():
+    """Stop the currently running Gradio app"""
+    if st.session_state.app_interface:
+        # Close the Gradio interface
+        try:
+            st.session_state.app_interface.close()
+        except:
+            pass
+    
+    # Clear the current app from session state
+    st.session_state.current_app = None
+    st.session_state.current_app_module = None
+    st.session_state.app_interface = None
+
+# Create the Streamlit UI
+st.title("🧩 Gradio Examples Hub")
+st.write("Discover and run various Gradio examples directly in this app.")
+
+# Create tabs for different sections
+tab_examples, tab_custom = st.tabs(["Built-in Examples", "Custom Code"])
+
+# Built-in Examples tab
+with tab_examples:
+    st.header("Built-in Examples")
+    
+    # Example selection
+    example_options = list(EXAMPLES.keys())
+    example_names = {
+        "hello_world": "Hello World",
+        "calculator": "Simple Calculator",
+        "image_filter": "Image Filter",
+        "text_analysis": "Text Analysis",
+        "chatbot": "Simple Chatbot",
+        "audio_player": "Audio Tone Generator"
+    }
+    
+    selected_example = st.selectbox(
+        "Select an example", 
+        example_options,
+        format_func=lambda x: example_names.get(x, x)
+    )
+    
+    # Show description
+    example_descriptions = {
+        "hello_world": "A simple app that greets you by name.",
+        "calculator": "Perform basic arithmetic operations between two numbers.",
+        "image_filter": "Apply various filters to images (grayscale, invert, sepia).",
+        "text_analysis": "Count characters, words, and lines in text.",
+        "chatbot": "A simple echo chatbot example.",
+        "audio_player": "Generate audio tones with adjustable frequency and duration."
+    }
+    
+    st.write(example_descriptions.get(selected_example, ""))
+    
+    # Show code
+    with st.expander("View Code"):
+        st.code(EXAMPLES[selected_example], language="python")
+    
+    # Run example button
+    if st.button("Run Example", key="run_example"):
+        stop_current_app()  # Stop any running app
         
-        st.code(code, language="python")
+        with st.spinner("Loading example..."):
+            # Load the example
+            module, demo = load_example(selected_example)
+            
+            # Update session state
+            st.session_state.current_app = selected_example
+            st.session_state.current_app_module = module
+            st.session_state.app_interface = demo
+            
+            # Rerun the app to refresh the UI
+            st.experimental_rerun()
 
-# Custom generator tab
-with tab2:
-    st.header("Generate Custom App")
+# Custom Code tab
+with tab_custom:
+    st.header("Custom Gradio Code")
+    st.write("Write or paste your own Gradio code here.")
     
-    api_key = st.text_input("OpenAI API Key", type="password", help="Your OpenAI API key")
-    app_description = st.text_area("Describe the app you want", height=100)
+    # Code editor
+    custom_code = st.text_area(
+        "Gradio Code", 
+        height=300,
+        placeholder="# Paste your Gradio code here\nimport gradio as gr\n\n# Define your functions\ndef my_function(input):\n    return input\n\n# Create the interface\ndemo = gr.Interface(...)"
+    )
     
-    if st.button("Generate Custom App"):
-        if not api_key or len(api_key) < 20:
-            st.error("Please enter a valid OpenAI API key")
-        elif not app_description:
-            st.error("Please enter a description for your app")
+    # Run custom code button
+    if st.button("Run Custom Code", key="run_custom"):
+        if not custom_code.strip():
+            st.error("Please enter some code")
         else:
-            with st.spinner("Generating app..."):
-                code, error = get_openai_code(api_key, app_description)
+            stop_current_app()  # Stop any running app
+            
+            with st.spinner("Loading custom code..."):
+                # Create the custom example
+                module, demo, error = create_custom_example(custom_code)
                 
                 if error:
-                    st.error(f"Error generating code: {error}")
+                    st.error(error)
                 else:
-                    success, run_error = run_gradio_app(code)
-                    
-                    if success:
-                        st.success("App started successfully!")
-                    else:
-                        st.error(f"Failed to start app: {run_error}")
+                    # Update session state
+                    st.session_state.current_app = "custom"
+                    st.session_state.current_app_module = module
+                    st.session_state.app_interface = demo
                     
-                    st.code(code, language="python")
+                    # Rerun the app to refresh the UI
+                    st.experimental_rerun()
 
-# Display the currently running app
-st.header("Running App")
+# Display the current app if there is one
+st.header("Current App")
 
-if st.session_state.app_port:
-    # Create an iframe to display the app
-    st.components.v1.iframe(
-        src=f"http://localhost:{st.session_state.app_port}", 
-        height=600, 
-        scrolling=True
-    )
+if st.session_state.current_app:
+    app_name = st.session_state.current_app
+    demo = st.session_state.app_interface
     
-    if st.button("Stop App"):
-        if stop_running_app():
-            st.success("App stopped successfully")
-            st.experimental_rerun()
+    # Create a container for the app
+    app_container = st.container()
+    app_container.write(f"Running: {example_names.get(app_name, 'Custom App')}")
+    
+    # Create a unique key for the app
+    app_key = f"app_{app_name}_{uuid.uuid4().hex[:8]}"
+    
+    # Render the Gradio interface directly in Streamlit
+    with app_container:
+        gr.Interface.load(
+            fn=demo,
+            title=demo._title,
+            description=getattr(demo, "_description", ""),
+        ).render()
+    
+    # Stop button
+    if st.button("Stop App", key="stop_app"):
+        stop_current_app()
+        st.experimental_rerun()
 else:
-    st.info("No app is currently running. Generate an app first.")
+    st.info("No app is currently running. Select an example or create a custom app to get started.")
+
+# Footer
+st.markdown("---")
+st.markdown("### About this App")
+st.write(
+    "This Streamlit app demonstrates how to dynamically load and run Gradio interfaces. "
+    "It showcases integration between Streamlit for the main application UI and Gradio for "
+    "interactive demos."
+)