Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import requests | |
| import re | |
| import os | |
| import subprocess | |
| import tempfile | |
| import sys | |
| import json | |
| import time | |
| import atexit | |
| # Print Python version and gradio version for debugging | |
| print(f"Python version: {sys.version}") | |
| print(f"Gradio version: {gr.__version__}") | |
| # Track running processes for cleanup | |
| running_process = None | |
| # Clean up running process on exit | |
| def cleanup_process(): | |
| global running_process | |
| if running_process and running_process.poll() is None: | |
| try: | |
| running_process.terminate() | |
| running_process.wait(timeout=5) | |
| print(f"Terminated process {running_process.pid}") | |
| except Exception as e: | |
| print(f"Error terminating process: {e}") | |
| atexit.register(cleanup_process) | |
| def call_openai_api(api_key, prompt): | |
| """Call OpenAI API to generate Gradio app code and requirements""" | |
| headers = { | |
| "Content-Type": "application/json", | |
| "Authorization": f"Bearer {api_key}" | |
| } | |
| system_prompt = """You are an expert at creating Python applications with Gradio. | |
| Create a complete, standalone Gradio application based on the user's prompt. | |
| Provide your response in the following JSON format: | |
| { | |
| "app_code": "# Python code here...", | |
| "requirements": ["gradio==3.32.0", "other_packages"], | |
| "description": "Brief description of what the app does" | |
| } | |
| Important guidelines: | |
| 1. The app_code should be a complete Gradio application | |
| 2. Use ONLY gr.Interface (NOT gr.Blocks) | |
| 3. Always include server_name="0.0.0.0" and server_port=7861 in the launch parameters | |
| 4. First requirement must be exactly "gradio==3.32.0" | |
| 5. Keep the app simple and focused on the user's request | |
| 6. DO NOT use any flagging callbacks | |
| 7. DO NOT create or use any directories or file paths | |
| Example: | |
| ```python | |
| import gradio as gr | |
| import numpy as np | |
| def process(input_value): | |
| return input_value * 2 | |
| demo = gr.Interface( | |
| fn=process, | |
| inputs=gr.Number(label="Input"), | |
| outputs=gr.Number(label="Output"), | |
| title="Number Doubler" | |
| ) | |
| demo.launch(server_name="0.0.0.0", server_port=7861) | |
| ``` | |
| """ | |
| data = { | |
| "model": "gpt-4o", | |
| "messages": [ | |
| {"role": "system", "content": system_prompt}, | |
| {"role": "user", "content": prompt} | |
| ], | |
| "temperature": 0.2, | |
| "max_tokens": 4000 | |
| } | |
| try: | |
| response = requests.post( | |
| "https://api.openai.com/v1/chat/completions", | |
| headers=headers, | |
| json=data | |
| ) | |
| if response.status_code != 200: | |
| return None, f"API Error: {response.status_code} - {response.text}" | |
| result = response.json() | |
| content = result["choices"][0]["message"]["content"] | |
| # Try to parse the JSON response | |
| try: | |
| # Look for JSON object | |
| json_pattern = r'({[\s\S]*})' | |
| json_match = re.search(json_pattern, content) | |
| if json_match: | |
| json_str = json_match.group(1) | |
| app_info = json.loads(json_str) | |
| else: | |
| # Try to extract code and requirements manually | |
| code_pattern = r'```python\s*([\s\S]*?)```' | |
| code_match = re.search(code_pattern, content) | |
| if not code_match: | |
| return None, "No code found in the response" | |
| code = code_match.group(1) | |
| # Extract requirements from imports | |
| req_pattern = r'import\s+([a-zA-Z0-9_]+)' | |
| req_matches = re.findall(req_pattern, code) | |
| requirements = ["gradio==3.32.0"] | |
| for module in req_matches: | |
| if module != "gradio" and module not in requirements and module not in ["os", "sys"]: | |
| requirements.append(module) | |
| app_info = { | |
| "app_code": code, | |
| "requirements": requirements, | |
| "description": "Generated Gradio application" | |
| } | |
| # Clean up the code if needed | |
| if "```python" in app_info["app_code"]: | |
| code_pattern = r'```python\s*([\s\S]*?)```' | |
| code_match = re.search(code_pattern, app_info["app_code"]) | |
| if code_match: | |
| app_info["app_code"] = code_match.group(1) | |
| return app_info, None | |
| except Exception as e: | |
| return None, f"Failed to parse API response: {str(e)}" | |
| except Exception as e: | |
| return None, f"API call failed: {str(e)}" | |
| def install_and_run_app(code, requirements): | |
| """Install requirements and run the app in a subprocess""" | |
| global running_process | |
| try: | |
| # Clean up any previous process | |
| if running_process and running_process.poll() is None: | |
| running_process.terminate() | |
| running_process.wait(timeout=5) | |
| # Create a temporary file for the app | |
| fd, app_file = tempfile.mkstemp(suffix='.py') | |
| os.close(fd) | |
| with open(app_file, 'w') as f: | |
| f.write(code) | |
| # Install requirements | |
| install_output = "" | |
| for req in requirements: | |
| try: | |
| cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--no-cache-dir", req] | |
| result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=120) | |
| install_output += f"Installing {req}: {'SUCCESS' if result.returncode == 0 else 'FAILED'}\n" | |
| if result.returncode != 0: | |
| install_output += f"Error: {result.stderr}\n" | |
| except Exception as e: | |
| install_output += f"Error installing {req}: {str(e)}\n" | |
| # Run the app | |
| running_process = subprocess.Popen( | |
| [sys.executable, app_file], | |
| stdout=subprocess.PIPE, | |
| stderr=subprocess.PIPE, | |
| text=True | |
| ) | |
| # Wait a bit for the app to start | |
| time.sleep(5) | |
| # Check if the process is still running | |
| if running_process.poll() is not None: | |
| stdout, stderr = running_process.communicate() | |
| os.unlink(app_file) | |
| return None, f"App failed to start:\n{stderr}\n\nInstallation log:\n{install_output}" | |
| return { | |
| "app_file": app_file, | |
| "install_output": install_output | |
| }, None | |
| except Exception as e: | |
| if 'app_file' in locals() and os.path.exists(app_file): | |
| os.unlink(app_file) | |
| return None, f"Error setting up and running app: {str(e)}" | |
| def stop_running_app(): | |
| """Stop the running app""" | |
| global running_process | |
| if running_process and running_process.poll() is None: | |
| try: | |
| running_process.terminate() | |
| running_process.wait(timeout=5) | |
| running_process = None | |
| return True | |
| except Exception as e: | |
| print(f"Error stopping app: {str(e)}") | |
| running_process = None | |
| return False | |
| # Create the Gradio interface | |
| with gr.Blocks(title="Gradio App Generator") as demo: | |
| gr.Markdown("# 🤖 Gradio App Generator") | |
| gr.Markdown(""" | |
| This app generates a Gradio application based on your description, installs required packages, | |
| and runs it directly. The generated app will be displayed below. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| api_key = gr.Textbox( | |
| label="OpenAI API Key", | |
| placeholder="sk-...", | |
| type="password", | |
| info="Your key is used only for this session" | |
| ) | |
| prompt = gr.Textbox( | |
| label="App Description", | |
| placeholder="Describe the Gradio app you want to create...", | |
| lines=5 | |
| ) | |
| with gr.Row(): | |
| generate_btn = gr.Button("Generate & Run App", variant="primary") | |
| stop_btn = gr.Button("Stop Running App", variant="stop", visible=False) | |
| with gr.Accordion("Generated Code", open=False): | |
| code_output = gr.Code(language="python", label="App Code") | |
| with gr.Accordion("Installation Log", open=False): | |
| install_output = gr.Textbox(label="Package Installation Log", lines=5) | |
| status_output = gr.Markdown("") | |
| with gr.Column(scale=2): | |
| # Frame to display the running app | |
| app_frame = gr.HTML("<div style='text-align:center; padding:50px;'><h3>Your generated app will appear here</h3></div>") | |
| # App file path storage | |
| app_file_state = gr.State(None) | |
| def on_generate(api_key_val, prompt_val): | |
| # Validate API key | |
| if not api_key_val or len(api_key_val) < 20 or not api_key_val.startswith("sk-"): | |
| return ( | |
| None, None, "⚠️ Please provide a valid OpenAI API key", | |
| "<div style='text-align:center; padding:50px;'><h3>Invalid API key</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| try: | |
| # Generate app code and requirements | |
| status_message = "⏳ Generating app code..." | |
| yield ( | |
| None, None, status_message, | |
| "<div style='text-align:center; padding:50px;'><h3>Generating code...</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| app_info, error = call_openai_api(api_key_val, prompt_val) | |
| if error or not app_info: | |
| return ( | |
| None, None, f"⚠️ {error or 'Failed to generate app'}", | |
| "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| code = app_info["app_code"] | |
| requirements = app_info["requirements"] | |
| # Make sure server_name and server_port are specified | |
| if "server_name" not in code or "server_port" not in code: | |
| if "demo.launch(" in code: | |
| code = code.replace("demo.launch(", "demo.launch(server_name=\"0.0.0.0\", server_port=7861, ") | |
| else: | |
| code += "\n\ndemo.launch(server_name=\"0.0.0.0\", server_port=7861)" | |
| status_message = "⏳ Installing packages and starting app..." | |
| yield ( | |
| code, None, status_message, | |
| "<div style='text-align:center; padding:50px;'><h3>Installing packages...</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| # Install packages and run the app | |
| run_result, run_error = install_and_run_app(code, requirements) | |
| if run_error or not run_result: | |
| return ( | |
| code, None, f"⚠️ {run_error}", | |
| "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| # Show the app in an iframe | |
| iframe_html = f""" | |
| <div style="height:600px; border:1px solid #ddd; border-radius:5px; overflow:hidden;"> | |
| <iframe src="http://localhost:7861" width="100%" height="100%" frameborder="0"></iframe> | |
| </div> | |
| """ | |
| return ( | |
| code, run_result["install_output"], f"✅ App is running! View it below.", | |
| iframe_html, gr.update(visible=True), run_result["app_file"] | |
| ) | |
| except Exception as e: | |
| import traceback | |
| error_details = traceback.format_exc() | |
| return ( | |
| None, None, f"⚠️ Error: {str(e)}\n\n{error_details}", | |
| "<div style='text-align:center; padding:50px;'><h3>An error occurred</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| def on_stop(app_file): | |
| stopped = stop_running_app() | |
| # Clean up the app file | |
| if app_file and os.path.exists(app_file): | |
| try: | |
| os.unlink(app_file) | |
| except: | |
| pass | |
| if stopped: | |
| return ( | |
| "✅ App stopped successfully", | |
| "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| else: | |
| return ( | |
| "⚠️ No app was running", | |
| "<div style='text-align:center; padding:50px;'><h3>No app was running</h3></div>", | |
| gr.update(visible=False), None | |
| ) | |
| generate_btn.click( | |
| on_generate, | |
| inputs=[api_key, prompt], | |
| outputs=[ | |
| code_output, install_output, status_output, app_frame, | |
| stop_btn, app_file_state | |
| ] | |
| ) | |
| stop_btn.click( | |
| on_stop, | |
| inputs=[app_file_state], | |
| outputs=[status_output, app_frame, stop_btn, app_file_state] | |
| ) | |
| if __name__ == "__main__": | |
| # Make sure we're not trying to use flagging | |
| demo.launch(server_name="0.0.0.0", server_port=7860, flagging_callback=None) |