Update app.py

app.py

@@ -1,41 +1,19 @@
-import streamlit as st
 import gradio as gr
 import importlib.util
 import sys
-import tempfile
 import os
+import tempfile
 from pathlib import Path
-import inspect
-import types
-import shutil
-import uuid
 
-# Configure the Streamlit page
-st.set_page_config(
-    page_title="Gradio Examples Hub",
-    page_icon="🧩",
-    layout="wide"
-)
-
-# Directory structure
-EXAMPLES_DIR = Path("gradio_examples")
+# Create directory for examples
+EXAMPLES_DIR = Path("examples")
 EXAMPLES_DIR.mkdir(exist_ok=True)
 
-# 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()
-
-# Ensure the examples directory is in the Python path
+# Ensure examples directory is in Python path
 if str(EXAMPLES_DIR.absolute()) not in sys.path:
+    sys.modules["examples"] = type(sys)("examples")
     sys.path.insert(0, str(EXAMPLES_DIR.absolute()))
 
-# 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
-
 # Example Gradio apps as Python code
 EXAMPLES = {
     "hello_world": """
@@ -50,7 +28,7 @@ demo = gr.Interface(
     outputs=gr.Textbox(label="Greeting"),
     title="Hello World App",
     description="A simple app that greets you by name",
-    examples=[["World"], ["Gradio"], ["Streamlit"]]
+    examples=[["World"], ["Gradio"], ["User"]]
 )
 """,
 
@@ -125,259 +103,124 @@ demo = gr.Interface(
     title="Image Filter App",
     description="Apply various filters to your images"
 )
-""",
-
-    "text_analysis": """
-import gradio as gr
-
-def analyze_text(text):
-    if not text:
-        return "Please enter some text"
-    
-    char_count = len(text)
-    word_count = len(text.split())
-    line_count = len(text.splitlines())
-    
-    return f"Characters: {char_count}\\nWords: {word_count}\\nLines: {line_count}"
-
-demo = gr.Interface(
-    fn=analyze_text,
-    inputs=gr.Textbox(label="Enter Text", lines=5),
-    outputs=gr.Textbox(label="Analysis"),
-    title="Text Analysis Tool",
-    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 = 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"
-)
 """
 }
 
+# Function to dynamically load a Gradio example
 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"
+    """Load a example module and return the demo instance"""
+    # Create a module file
+    module_path = EXAMPLES_DIR / f"{example_name}.py"
     
-    # Write the example code to a file
-    with open(file_path, "w") as f:
+    # Write the example code to the file
+    with open(module_path, "w") as f:
         f.write(EXAMPLES[example_name])
     
     # Import the module
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    spec = importlib.util.spec_from_file_location(f"examples.{example_name}", module_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
+    # Return the demo object
+    return module.demo
 
-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"
-    
-    # Write the code to a file
-    with open(file_path, "w") as f:
-        f.write(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)
+# Main selector app
+def selector_app():
+    with gr.Blocks(title="Gradio Examples Selector") as selector:
+        with gr.Row():
+            gr.Markdown("# Gradio Examples Hub")
         
-        # Check if the module has a demo attribute
-        if hasattr(module, 'demo'):
-            return module, module.demo, None
-        else:
-            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
+        with gr.Row():
+            gr.Markdown("Select an example to run:")
         
-        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 Code tab
-with tab_custom:
-    st.header("Custom Gradio Code")
-    st.write("Write or paste your own Gradio code here.")
-    
-    # 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(...)"
-    )
+        example_names = {
+            "hello_world": "Hello World Greeter",
+            "calculator": "Simple Calculator",
+            "image_filter": "Image Filter"
+        }
+        
+        with gr.Row():
+            example_dropdown = gr.Dropdown(
+                choices=list(EXAMPLES.keys()),
+                value="hello_world",
+                label="Select Example",
+                format_func=lambda x: example_names.get(x, x)
+            )
+        
+        with gr.Row():
+            load_btn = gr.Button("Load Example", variant="primary")
+        
+        # Info area for example descriptions
+        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 (grayscale, invert, sepia) to images."
+        }
+        
+        info_box = gr.Markdown(f"**{example_names['hello_world']}**: {example_descriptions['hello_world']}")
+        
+        # Update description when dropdown changes
+        def update_description(example):
+            return f"**{example_names[example]}**: {example_descriptions[example]}"
+        
+        example_dropdown.change(
+            update_description,
+            inputs=[example_dropdown],
+            outputs=[info_box]
+        )
+        
+        # Function to load the selected example
+        def load_selected_example(example_name):
+            # Return the app name to be loaded
+            return example_name
+        
+        # Connect the load button
+        load_btn.click(
+            load_selected_example,
+            inputs=[example_dropdown],
+            outputs=[gr.Textbox(visible=False)]
+        )
     
-    # 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:
-            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(error)
-                else:
-                    # Update session state
-                    st.session_state.current_app = "custom"
-                    st.session_state.current_app_module = module
-                    st.session_state.app_interface = demo
-                    
-                    # Rerun the app to refresh the UI
-                    st.experimental_rerun()
+    return selector
 
-# Display the current app if there is one
-st.header("Current App")
-
-if st.session_state.current_app:
-    app_name = st.session_state.current_app
-    demo = st.session_state.app_interface
-    
-    # Create a container for the app
-    app_container = st.container()
-    app_container.write(f"Running: {example_names.get(app_name, 'Custom App')}")
+# Create a function to determine which app to launch
+def get_current_app():
+    # Check if an example was requested in the URL
+    example_name = None
     
-    # Create a unique key for the app
-    app_key = f"app_{app_name}_{uuid.uuid4().hex[:8]}"
+    # Get query parameters from URL
+    try:
+        import urllib.parse
+        query_params = dict(urllib.parse.parse_qsl(os.environ.get('QUERY_STRING', '')))
+        example_name = query_params.get('example', None)
+    except:
+        pass
     
-    # Render the Gradio interface directly in Streamlit
-    with app_container:
-        gr.Interface.load(
-            fn=demo,
-            title=demo._title,
-            description=getattr(demo, "_description", ""),
-        ).render()
+    # If no example specified, return the selector app
+    if not example_name or example_name not in EXAMPLES:
+        return selector_app()
     
-    # Stop button
-    if st.button("Stop App", key="stop_app"):
-        stop_current_app()
-        st.experimental_rerun()
-else:
-    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."
-)
+    # Otherwise, load the requested example
+    try:
+        return load_example(example_name)
+    except Exception as e:
+        print(f"Error loading example {example_name}: {str(e)}")
+        return selector_app()
+
+# Launch the app based on URL parameters
+app = get_current_app()
+
+# When an example is selected, redirect to load it
+if isinstance(app, gr.Blocks) and app.title == "Gradio Examples Selector":
+    @app.load(api_name=False)
+    def on_load():
+        pass
+    
+    # Handle example selection
+    @app.callback(inputs=[gr.Textbox(visible=False)], outputs=None)
+    def on_example_selected(example_name):
+        if example_name:
+            gr.Blocks.redirect(f"?example={example_name}")
+
+# Launch the appropriate app
+app.launch(server_name="0.0.0.0", server_port=7860)