Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import os | |
| import io | |
| from contextlib import redirect_stdout, redirect_stderr | |
| # Set fixed MPLCONFIGDIR to avoid permission issues | |
| os.environ['MPLCONFIGDIR'] = '/tmp' | |
| # Sample code for different Gradio apps | |
| EXAMPLE_CODES = { | |
| "hello_world": """ | |
| import gradio as gr | |
| 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", | |
| description="A simple greeting app" | |
| ) | |
| """, | |
| "calculator": """ | |
| import gradio as gr | |
| 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", | |
| description="Perform basic arithmetic operations" | |
| ) | |
| """, | |
| "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": | |
| 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", | |
| description="Apply various filters to images" | |
| ) | |
| """ | |
| } | |
| # 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 | |
| # Function to execute code and extract the demo object | |
| def execute_code(code): | |
| """Execute the code and return the demo object""" | |
| # Create a clean namespace | |
| namespace = {} | |
| # Capture stdout and stderr | |
| stdout_buffer = io.StringIO() | |
| stderr_buffer = io.StringIO() | |
| try: | |
| with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer): | |
| # Execute the code in the namespace | |
| exec(code, namespace) | |
| # Check if 'demo' exists in the namespace | |
| if 'demo' not in namespace: | |
| return None, "No 'demo' object found in the code", stdout_buffer.getvalue(), stderr_buffer.getvalue() | |
| # Return the demo object | |
| return namespace['demo'], None, stdout_buffer.getvalue(), stderr_buffer.getvalue() | |
| except Exception as e: | |
| import traceback | |
| return None, f"Error executing code: {str(e)}\n{traceback.format_exc()}", stdout_buffer.getvalue(), stderr_buffer.getvalue() | |
| # Main app | |
| with gr.Blocks(title="LLM Gradio App Generator") as app: | |
| # Header | |
| gr.Markdown("# 🤖 LLM Gradio App Generator") | |
| gr.Markdown("Generate and run Gradio apps dynamically!") | |
| with gr.Row(): | |
| # Input column | |
| 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 | |
| ) | |
| # Example buttons | |
| gr.Markdown("### Example Prompts") | |
| hello_btn = gr.Button("Hello World App") | |
| calc_btn = gr.Button("Calculator App") | |
| img_btn = gr.Button("Image Filter App") | |
| # Generate button | |
| generate_btn = gr.Button("Generate & Run App", variant="primary") | |
| # Code display | |
| gr.Markdown("### Generated Code") | |
| code_display = gr.Code(language="python") | |
| # Log output | |
| with gr.Accordion("Execution Log", open=False): | |
| log_output = gr.Textbox(label="Output Log", lines=5) | |
| # Output column | |
| with gr.Column(scale=2): | |
| # Status message | |
| status_msg = gr.Markdown("### Generated App Will Appear Here") | |
| # Container for the dynamically generated app | |
| app_container = gr.HTML( | |
| """<div style="display:flex; justify-content:center; align-items:center; height:400px; border:1px dashed #ccc; border-radius:8px;"> | |
| <div style="text-align:center;"> | |
| <h3>No App Generated Yet</h3> | |
| <p>Enter a description and click "Generate & Run App"</p> | |
| </div> | |
| </div>""" | |
| ) | |
| # Example button functions | |
| def set_prompt(text): | |
| return text | |
| hello_btn.click( | |
| lambda: set_prompt("A simple hello world app that greets the user by name"), | |
| inputs=None, | |
| outputs=prompt | |
| ) | |
| calc_btn.click( | |
| lambda: set_prompt("A calculator app that can add, subtract, multiply and divide two numbers"), | |
| inputs=None, | |
| outputs=prompt | |
| ) | |
| img_btn.click( | |
| lambda: set_prompt("An image filter app that can apply grayscale, invert, and sepia filters to images"), | |
| inputs=None, | |
| outputs=prompt | |
| ) | |
| # Main function to generate and run the app | |
| def generate_and_run_app(prompt_text): | |
| if not prompt_text: | |
| return ( | |
| "Please enter a description of the app you want to generate.", | |
| "", | |
| """<div style="text-align:center; padding:20px;"> | |
| <h3>No App Generated</h3> | |
| <p>Please enter a description first.</p> | |
| </div>""" | |
| ) | |
| # Get code from LLM (simulated) | |
| code, error = simulate_llm_response(prompt_text) | |
| if error: | |
| return ( | |
| code, | |
| f"Error generating code: {error}", | |
| """<div style="text-align:center; color:red; padding:20px;"> | |
| <h3>Error</h3> | |
| <p>{0}</p> | |
| </div>""".format(error) | |
| ) | |
| # Execute the code | |
| demo_obj, exec_error, stdout, stderr = execute_code(code) | |
| log_output = f"STDOUT:\n{stdout}\n\nSTDERR:\n{stderr}" | |
| if exec_error: | |
| return ( | |
| code, | |
| f"Error: {exec_error}", | |
| """<div style="text-align:center; color:red; padding:20px;"> | |
| <h3>Execution Error</h3> | |
| <p>{0}</p> | |
| </div>""".format(exec_error) | |
| ) | |
| try: | |
| # Render the demo to HTML | |
| rendered_html = demo_obj.render().replace('window.gradio_mode = "app";', '') | |
| return code, f"✅ App generated and running!", rendered_html | |
| except Exception as e: | |
| import traceback | |
| return ( | |
| code, | |
| f"Error rendering app: {str(e)}", | |
| """<div style="text-align:center; color:red; padding:20px;"> | |
| <h3>Rendering Error</h3> | |
| <p>{0}</p> | |
| </div>""".format(traceback.format_exc()) | |
| ) | |
| # Connect the generate button | |
| generate_btn.click( | |
| generate_and_run_app, | |
| inputs=prompt, | |
| outputs=[code_display, log_output, app_container] | |
| ) | |
| # Launch the app | |
| if __name__ == "__main__": | |
| app.launch(server_name="0.0.0.0", server_port=7860) |