Update app.py

app.py

@@ -1,22 +1,19 @@
 import gradio as gr
-import importlib.util
-import sys
 import os
-import tempfile
+import sys
 from pathlib import Path
+import importlib.util
 
-# Create directory for examples
+# Create examples directory
 EXAMPLES_DIR = Path("examples")
 EXAMPLES_DIR.mkdir(exist_ok=True)
 
-# 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()))
-
-# Example Gradio apps as Python code
+# Pre-defined Gradio examples
 EXAMPLES = {
-    "hello_world": """
+    "hello_world": {
+        "title": "Hello World Greeter",
+        "description": "A simple app that greets you by name",
+        "code": """
 import gradio as gr
 
 def greet(name):
@@ -24,17 +21,19 @@ def greet(name):
 
 demo = gr.Interface(
     fn=greet,
-    inputs=gr.Textbox(label="Your Name", placeholder="Enter your name"),
+    inputs=gr.Textbox(label="Your Name"),
     outputs=gr.Textbox(label="Greeting"),
-    title="Hello World App",
-    description="A simple app that greets you by name",
-    examples=[["World"], ["Gradio"], ["User"]]
+    title="Hello World Greeter",
+    description="A simple app that greets you by name"
 )
-""",
-
-    "calculator": """
+"""
+    },
+    
+    "calculator": {
+        "title": "Simple Calculator",
+        "description": "Perform basic arithmetic operations",
+        "code": """
 import gradio as gr
-import numpy as np
 
 def calculate(num1, num2, operation):
     if operation == "Add":
@@ -57,17 +56,15 @@ demo = gr.Interface(
     ],
     outputs=gr.Textbox(label="Result"),
     title="Simple Calculator",
-    description="Perform basic arithmetic operations",
-    examples=[
-        [5, 3, "Add"],
-        [10, 4, "Subtract"],
-        [6, 7, "Multiply"],
-        [20, 4, "Divide"]
-    ]
+    description="Perform basic arithmetic operations"
 )
-""",
-
-    "image_filter": """
+"""
+    },
+    
+    "image_filter": {
+        "title": "Image Filter",
+        "description": "Apply various filters to your images",
+        "code": """
 import gradio as gr
 import numpy as np
 from PIL import Image
@@ -100,127 +97,82 @@ demo = gr.Interface(
         gr.Radio(["Grayscale", "Invert", "Sepia"], label="Filter")
     ],
     outputs=gr.Image(type="pil"),
-    title="Image Filter App",
+    title="Image Filter",
     description="Apply various filters to your images"
 )
 """
+    }
 }
 
-# Function to dynamically load a Gradio example
-def load_example(example_name):
-    """Load a example module and return the demo instance"""
-    # Create a module file
-    module_path = EXAMPLES_DIR / f"{example_name}.py"
+# Function to load and run a specific example
+def run_example(example_name):
+    example = EXAMPLES.get(example_name)
+    if not example:
+        return None
     
-    # Write the example code to the file
+    # Create module file
+    module_path = EXAMPLES_DIR / f"{example_name}.py"
     with open(module_path, "w") as f:
-        f.write(EXAMPLES[example_name])
-    
-    # Import the module
-    spec = importlib.util.spec_from_file_location(f"examples.{example_name}", module_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
+        f.write(example["code"])
     
-    # Return the demo object
-    return module.demo
-
-# Main selector app
-def selector_app():
-    with gr.Blocks(title="Gradio Examples Selector") as selector:
-        with gr.Row():
-            gr.Markdown("# Gradio Examples Hub")
-        
-        with gr.Row():
-            gr.Markdown("Select an example to run:")
-        
-        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
+    try:
+        # Import the module
+        spec = importlib.util.spec_from_file_location(f"examples.{example_name}", module_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[f"examples.{example_name}"] = module
+        spec.loader.exec_module(module)
         
-        # Connect the load button
-        load_btn.click(
-            load_selected_example,
-            inputs=[example_dropdown],
-            outputs=[gr.Textbox(visible=False)]
-        )
+        if hasattr(module, 'demo'):
+            return module.demo
+    except Exception as e:
+        print(f"Error loading example {example_name}: {e}")
     
-    return selector
+    return None
 
-# 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
+# Main selector interface
+def example_selector():
+    """Create a simple selector interface"""
     
-    # 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
+    def select_example(example_name):
+        """Callback when an example is selected"""
+        demo = run_example(example_name)
+        if demo:
+            demo.launch(server_name="0.0.0.0", server_port=7860)
+        return f"Selected {example_name}, please restart the server to see it."
     
-    # If no example specified, return the selector app
-    if not example_name or example_name not in EXAMPLES:
-        return selector_app()
+    demo = gr.Interface(
+        fn=select_example,
+        inputs=gr.Radio(
+            choices=list(EXAMPLES.keys()),
+            label="Select an example to run",
+            info="Choose one of the examples below"
+        ),
+        outputs=gr.Textbox(label="Status"),
+        title="Gradio Examples Selector",
+        description="Select an example from the list to run it.",
+        allow_flagging=False
+    )
     
-    # 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()
+    return demo
 
-# Launch the app based on URL parameters
-app = get_current_app()
+# Get example from environment variables if set
+def get_example_from_env():
+    """Check if an example is specified in the environment"""
+    return os.environ.get("GRADIO_EXAMPLE", None)
 
-# 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
+# Main application logic
+if __name__ == "__main__":
+    # Check if we should load a specific example
+    example_name = get_example_from_env()
     
-    # 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)
+    if example_name in EXAMPLES:
+        demo = run_example(example_name)
+        if demo:
+            print(f"Running example: {example_name}")
+            demo.launch(server_name="0.0.0.0", server_port=7860)
+        else:
+            print(f"Failed to load example: {example_name}, falling back to selector")
+            example_selector().launch(server_name="0.0.0.0", server_port=7860)
+    else:
+        # Run the selector interface
+        example_selector().launch(server_name="0.0.0.0", server_port=7860)