Update app.py

app.py

@@ -1,113 +1,104 @@
 import gradio as gr
 import requests
 import re
-import tempfile
-import importlib.util
-import sys
 import os
-import traceback
-
-# Print Gradio version for debugging
-GRADIO_VERSION = gr.__version__
-print(f"Using Gradio version: {GRADIO_VERSION}")
-
-# Minimal hardcoded apps that should work with any Gradio version
-HELLO_WORLD_APP = """
-import gradio as gr
-
-def hello_world():
-    return "Hello, World!"
-
-demo = gr.Interface(
-    fn=hello_world,
-    inputs=None,
-    outputs="text"
-)
-"""
+import subprocess
+import uuid
+import time
+import json
+import sys
+import importlib.util
+import tempfile
+import signal
+import atexit
+from pathlib import Path
 
-CALCULATOR_APP = """
-import gradio as gr
+# Print Python version info for debugging
+print(f"Python version: {sys.version}")
+print(f"Python executable: {sys.executable}")
 
-def calculate(a, b, operation):
-    if operation == "add":
-        return a + b
-    elif operation == "subtract":
-        return a - b
-    elif operation == "multiply":
-        return a * b
-    elif operation == "divide":
-        return a / b if b != 0 else "Error: Division by zero"
-    else:
-        return "Invalid operation"
+# Application directories
+APP_DIR = Path(os.getcwd())
+VENV_DIR = APP_DIR / "venvs"
+os.makedirs(VENV_DIR, exist_ok=True)
 
-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="text"
-)
-"""
+# Make sure we have virtualenv installed
+try:
+    import venv
+    print("venv module available")
+except ImportError:
+    subprocess.run([sys.executable, "-m", "pip", "install", "virtualenv"], check=True)
+    print("Installed virtualenv")
 
-TEXT_ANALYZER_APP = """
-import gradio as gr
+# Track running processes
+running_processes = []
 
-def analyze_text(text):
-    if not text:
-        return "Please enter some text"
-    
-    num_chars = len(text)
-    num_words = len(text.split())
-    
-    return f"Characters: {num_chars}, Words: {num_words}"
+# Clean up any running processes on exit
+def cleanup_processes():
+    for process in running_processes:
+        try:
+            if process.poll() is None:  # If process is still running
+                process.terminate()
+                process.wait(timeout=5)
+                print(f"Terminated process {process.pid}")
+        except Exception as e:
+            print(f"Error terminating process: {e}")
 
-demo = gr.Interface(
-    fn=analyze_text,
-    inputs="text",
-    outputs="text"
-)
-"""
+atexit.register(cleanup_processes)
 
 def call_openai_api(api_key, prompt):
-    """Direct API call to OpenAI with minimal output requirements"""
+    """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 Gradio developer.
-Create a standalone Gradio application based on the user's prompt.
-Your response should ONLY include Python code without any explanation.
+    system_prompt = """You are an expert at creating Python applications with Gradio.
+Your task is to create a complete, standalone Gradio application based on the user's prompt.
+
+Provide your response in the following JSON format:
+{
+    "app_code": "# Your Python code here...",
+    "requirements": ["gradio==3.50.2", "numpy", "pandas", ...],
+    "app_name": "descriptive-name-of-app",
+    "description": "Brief description of what the app does"
+}
 
-IMPORTANT: Use the MOST BASIC Gradio features ONLY.
-- Use gr.Interface() instead of gr.Blocks()
-- Use string literals "text" for text inputs/outputs
-- Do not use any component methods like .click() or event handlers
-- Do not use component properties or attributes
-- Keep it extremely simple
+Important guidelines:
+1. The app_code should be a complete Gradio application.
+2. Include gradio.launch(server_name="0.0.0.0", server_port=8000) at the end of the app.
+3. Don't use any resource that requires internet access (no API calls).
+4. Only use libraries that can be installed via pip.
+5. First requirement should be gradio==3.50.2.
+6. Make sure your code only uses the import statements for packages in the requirements list.
+7. Make the app functionality self-contained and robust.
+8. Don't use any buttons' .click() methods or event handlers - use gr.Interface() instead.
+9. Don't create directories or write to any file paths.
+10. Don't use flagging callbacks or features.
+11. Don't use __name__ == "__main__" checks, just have the launch call at the end.
 
-Example of a valid app:
+Here's a simple template to follow:
 
 ```python
 import gradio as gr
+import numpy as np
 
-def my_function(text_input):
-    return f"You entered: {text_input}"
+# Define your functions here
+def process_data(input_data):
+    result = input_data * 2  # Simple example
+    return f"Processed: {result}"
 
+# Create the Gradio interface
 demo = gr.Interface(
-    fn=my_function,
-    inputs="text",
-    outputs="text"
+    fn=process_data,
+    inputs=gr.Number(label="Input Data"),
+    outputs=gr.Textbox(label="Result"),
+    title="Data Processor"
 )
-```
 
-The code must:
-1. Import only gradio and basic Python libraries
-2. Define simple functions
-3. Create a minimal gr.Interface named 'demo'
-4. NOT include a launch command or if __name__ == "__main__" block
+# Launch the app
+demo.launch(server_name="0.0.0.0", server_port=8000)
+```
 """
     
     data = {
@@ -131,154 +122,337 @@ The code must:
             return None, f"API Error: {response.status_code} - {response.text}"
         
         result = response.json()
-        return result["choices"][0]["message"]["content"], None
+        content = result["choices"][0]["message"]["content"]
+        
+        # Try to parse the JSON response
+        try:
+            # Extract JSON from response
+            json_pattern = r'```json\s*([\s\S]*?)```|({[\s\S]*})'
+            json_matches = re.findall(json_pattern, content)
+            
+            json_str = ""
+            for match in json_matches:
+                if match[0]:  # From code block
+                    json_str = match[0]
+                    break
+                elif match[1]:  # Direct JSON
+                    json_str = match[1]
+                    break
+            
+            if not json_str:
+                json_str = content  # Try the whole content
+            
+            app_info = json.loads(json_str)
+            
+            # Extract Python code if it's wrapped in code blocks
+            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 json.JSONDecodeError:
+            # Fallback pattern matching if JSON parsing fails
+            app_code_pattern = r'```python\s*([\s\S]*?)```'
+            app_code_matches = re.findall(app_code_pattern, content)
+            
+            app_code = app_code_matches[0] if app_code_matches else ""
+            
+            if not app_code:
+                return None, "Could not extract app code from response"
+            
+            # Try to extract requirements
+            req_pattern = r'```(?:python)?\s*.*?import\s+([a-zA-Z0-9_]+)'
+            req_matches = re.findall(req_pattern, content)
+            
+            requirements = ["gradio==3.50.2"]
+            if req_matches:
+                for module in req_matches:
+                    if module != "gradio" and module not in requirements:
+                        requirements.append(module)
+            
+            # Construct a partial app_info
+            app_info = {
+                "app_code": app_code,
+                "requirements": requirements,
+                "app_name": f"gradio-app-{int(time.time())}",
+                "description": "Generated Gradio application"
+            }
+            
+            return app_info, None
     except Exception as e:
-        return None, f"API Error: {str(e)}"
+        return None, f"Error: {str(e)}"
 
-def extract_code_blocks(text):
-    """Extract code blocks from markdown"""
-    pattern = r'```(?:python)?\s*([\s\S]*?)```'
-    matches = re.findall(pattern, text)
-    
-    if not matches and text.strip():
-        if re.search(r'import\s+\w+|def\s+\w+\(|class\s+\w+:', text):
-            return [text.strip()]
-    
-    return [match.strip() for match in matches]
+def create_virtual_env(app_info):
+    """Create a virtual environment with the required packages"""
+    try:
+        # Create a unique ID for this app
+        app_id = str(uuid.uuid4())[:8]
+        app_name = f"{app_info['app_name']}-{app_id}"
+        venv_path = VENV_DIR / app_name
+        
+        # Create a virtual environment
+        print(f"Creating virtual environment at {venv_path}")
+        subprocess.run([sys.executable, "-m", "venv", str(venv_path)], check=True)
+        
+        # Determine the pip executable path
+        if os.name == 'nt':  # Windows
+            pip_path = venv_path / "Scripts" / "pip"
+        else:  # Unix/Linux
+            pip_path = venv_path / "bin" / "pip"
+        
+        # Install required packages
+        print(f"Installing packages: {', '.join(app_info['requirements'])}")
+        subprocess.run([str(pip_path), "install", "--upgrade", "pip"], check=True)
+        for req in app_info["requirements"]:
+            subprocess.run([str(pip_path), "install", req], check=True)
+        
+        return {
+            "app_id": app_id,
+            "app_name": app_name,
+            "venv_path": str(venv_path),
+            "pip_path": str(pip_path),
+            "description": app_info["description"],
+            "code": app_info["app_code"],
+            "requirements": app_info["requirements"]
+        }
+    except Exception as e:
+        return None, f"Error creating virtual environment: {str(e)}"
 
-def load_generated_app(code):
-    """Load and run the generated Gradio app"""
-    # Save code to temp file
-    with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
-        f.write(code.encode('utf-8'))
-        temp_file = f.name
-    
+def run_app_in_venv(app_details, app_code):
+    """Run the Gradio app in a virtual environment"""
     try:
-        # Import module
-        module_name = os.path.basename(temp_file).replace('.py', '')
-        spec = importlib.util.spec_from_file_location(module_name, temp_file)
-        module = importlib.util.module_from_spec(spec)
-        sys.modules[module_name] = module
-        spec.loader.exec_module(module)
+        # Determine the Python executable path
+        if os.name == 'nt':  # Windows
+            python_path = Path(app_details["venv_path"]) / "Scripts" / "python"
+        else:  # Unix/Linux
+            python_path = Path(app_details["venv_path"]) / "bin" / "python"
         
-        # Get the Gradio interface
-        if hasattr(module, 'demo'):
-            return module.demo, None
-        else:
-            return None, "No 'demo' variable found in the generated code"
-            
+        # Create a temporary file for the app code
+        with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
+            app_file = f.name
+            f.write(app_code.encode('utf-8'))
+        
+        # Change the port to 8000 if not already set
+        if "server_port" not in app_code:
+            with open(app_file, 'a') as f:
+                f.write("\n\n# Ensure the app is running on port 8000\nif 'demo' in locals():\n    demo.launch(server_name='0.0.0.0', server_port=8000)\n")
+        
+        # Run the app
+        print(f"Running app with Python: {python_path}")
+        process = subprocess.Popen(
+            [str(python_path), app_file],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        running_processes.append(process)
+        
+        # Wait a bit for the app to start
+        time.sleep(5)
+        
+        # Check if the process is still running
+        if process.poll() is not None:
+            stdout, stderr = process.communicate()
+            return None, f"App failed to start: {stderr}"
+        
+        return {
+            "process": process,
+            "app_file": app_file,
+            "url": "http://localhost:8000",
+            "process_id": process.pid
+        }, None
     except Exception as e:
-        error_details = traceback.format_exc()
-        return None, f"{str(e)}\n{error_details}"
-    finally:
-        try:
-            os.unlink(temp_file)
-        except:
-            pass
+        return None, f"Error running app: {str(e)}"
 
-def get_template_app(prompt_text):
-    """Get appropriate template app based on prompt keywords"""
-    prompt_lower = prompt_text.lower()
-    
-    if "hello" in prompt_lower or "world" in prompt_lower:
-        return HELLO_WORLD_APP
-    elif "calculator" in prompt_lower or "math" in prompt_lower or "calculate" in prompt_lower:
-        return CALCULATOR_APP
-    else:
-        return TEXT_ANALYZER_APP
+def stop_running_app(app_process):
+    """Stop a running Gradio app process"""
+    if app_process and app_process.poll() is None:
+        app_process.terminate()
+        try:
+            app_process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            app_process.kill()
+        
+        if app_process in running_processes:
+            running_processes.remove(app_process)
+        
+        return True
+    return False
 
-# Create the main UI - using the most basic approach
-with gr.Blocks() as demo:
-    gr.Markdown(f"# AI Gradio App Generator (v{GRADIO_VERSION})")
-    gr.Markdown("Describe the Gradio app you want, and I'll generate it for you.")
-    
-    api_key = gr.Textbox(
-        label="OpenAI API Key", 
-        placeholder="sk-...",
-        type="password"
-    )
+# 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 and runs it in a virtual environment
+    with the required dependencies. The generated app will be displayed below.
+    """)
     
-    prompt = gr.Textbox(
-        label="App Description", 
-        placeholder="Describe the Gradio app you want to create...",
-        lines=3
-    )
-    
-    submit_btn = gr.Button("Generate App")
-    template_btn = gr.Button("Use Template App")
-    
-    code_output = gr.Code(language="python", label="Generated Code")
-    status_output = gr.Textbox(label="Status")
+    # State variables to track the running app
+    running_app_process = gr.State(None)
+    running_app_file = gr.State(None)
     
-    app_container = gr.HTML(label="Generated App")
+    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
+            )
+            
+            install_bar = gr.HTML(
+                "<div id='install-status'></div>",
+                visible=False,
+                label="Installation Status"
+            )
+            
+            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("Requirements", open=False):
+                req_output = gr.Textbox(label="Required Packages")
+            
+            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>")
     
-    def on_submit(api_key_input, prompt_text):
+    def on_generate(api_key_val, prompt_val, running_process, app_file):
+        # Stop any previously running app
+        if running_process:
+            stop_running_app(running_process)
+        
+        # Clean up previous app file
+        if app_file and os.path.exists(app_file):
+            try:
+                os.unlink(app_file)
+            except:
+                pass
+        
         # Validate API key
-        if not api_key_input or len(api_key_input) < 20:
-            return None, "Please provide a valid OpenAI API key", "<p>Enter a valid API key</p>"
+        if not api_key_val or len(api_key_val) < 20 or not api_key_val.startswith("sk-"):
+            return (
+                None, 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), gr.update(visible=False), running_process, app_file
+            )
         
         try:
-            # Try to generate code via API
-            response, error = call_openai_api(api_key_input, prompt_text)
-            if error:
-                # Fall back to template if API fails
-                template_code = get_template_app(prompt_text)
-                app, app_error = load_generated_app(template_code)
-                
-                if app_error:
-                    return template_code, f"Template fallback also failed: {app_error}", "<p>Failed to generate app</p>"
-                
-                return template_code, "Using template app (API failed)", f"<iframe src='/template' width='100%' height='500px'></iframe>"
+            # Generate code via API
+            app_info, api_error = call_openai_api(api_key_val, prompt_val)
+            if api_error or not app_info:
+                return (
+                    None, None, None, f"⚠️ {api_error or 'Failed to generate app'}",
+                    "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>",
+                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                )
             
-            # Extract code from response
-            code_blocks = extract_code_blocks(response)
-            if not code_blocks:
-                template_code = get_template_app(prompt_text)
-                return template_code, "No code found in API response, using template", f"<iframe src='/template' width='100%' height='500px'></iframe>"
+            # Create virtual environment with required packages
+            install_status = f"<div style='padding:10px; background-color:#f0f0f0; border-radius:5px;'>"
+            install_status += f"<p>Creating virtual environment for '{app_info['app_name']}'...</p>"
+            install_status += f"<p>Installing packages: {', '.join(app_info['requirements'])}</p>"
+            install_status += "</div>"
             
-            code = code_blocks[0]
+            yield (
+                app_info["app_code"], "\n".join(app_info["requirements"]), None,
+                "⏳ Setting up virtual environment and installing packages...",
+                "<div style='text-align:center; padding:50px;'><h3>Preparing your app...</h3></div>",
+                gr.update(visible=True, value=install_status), gr.update(visible=False), running_process, app_file
+            )
             
-            # Try to load the generated app
-            app, app_error = load_generated_app(code)
-            if app_error:
-                # Fall back to template
-                template_code = get_template_app(prompt_text)
-                return template_code, f"Generated code error: {app_error}\nUsing template instead", f"<iframe src='/template' width='100%' height='500px'></iframe>"
+            venv_details, venv_error = create_virtual_env(app_info)
+            if venv_error or not venv_details:
+                return (
+                    app_info["app_code"], "\n".join(app_info["requirements"]), None,
+                    f"⚠️ {venv_error or 'Failed to create virtual environment'}",
+                    "<div style='text-align:center; padding:50px;'><h3>Error setting up environment</h3></div>",
+                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                )
             
-            return code, "App generated successfully!", f"<iframe src='/generated' width='100%' height='500px'></iframe>"
-        
+            # Run the app
+            app_result, app_error = run_app_in_venv(venv_details, app_info["app_code"])
+            if app_error or not app_result:
+                return (
+                    app_info["app_code"], "\n".join(app_info["requirements"]), None,
+                    f"⚠️ {app_error or 'Failed to run app'}",
+                    "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
+                    gr.update(visible=False), gr.update(visible=False), running_process, app_file
+                )
+            
+            # Display the running app in an iframe
+            iframe_html = f"""
+            <div style="height:600px; border:1px solid #ddd; border-radius:5px; overflow:hidden;">
+                <iframe src="http://localhost:8000" width="100%" height="100%" frameborder="0"></iframe>
+            </div>
+            """
+            
+            return (
+                app_info["app_code"], "\n".join(app_info["requirements"]), None,
+                f"✅ App '{venv_details['app_name']}' is running! View it below.",
+                iframe_html,
+                gr.update(visible=False), gr.update(visible=True), app_result["process"], app_result["app_file"]
+            )
         except Exception as e:
-            # Final fallback
-            template_code = get_template_app(prompt_text)
-            return template_code, f"Error: {str(e)}\nUsing template instead", f"<iframe src='/template' width='100%' height='500px'></iframe>"
+            import traceback
+            error_details = traceback.format_exc()
+            return (
+                None, 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), gr.update(visible=False), running_process, app_file
+            )
     
-    def on_template(prompt_text):
-        template_code = get_template_app(prompt_text)
-        return template_code, "Using built-in template app", f"<iframe src='/template' width='100%' height='500px'></iframe>"
+    def on_stop(running_process, app_file):
+        if running_process:
+            stopped = stop_running_app(running_process)
+            
+            # Clean up 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, None
+                )
+        
+        return (
+            "⚠️ No app was running", 
+            "<div style='text-align:center; padding:50px;'><h3>No app was running</h3></div>",
+            gr.update(visible=False), None, None
+        )
     
-    submit_btn.click(
-        on_submit,
-        inputs=[api_key, prompt],
-        outputs=[code_output, status_output, app_container]
+    generate_btn.click(
+        on_generate,
+        inputs=[api_key, prompt, running_app_process, running_app_file],
+        outputs=[
+            code_output, req_output, install_bar, status_output, app_frame, 
+            install_bar, stop_btn, running_app_process, running_app_file
+        ]
     )
     
-    template_btn.click(
-        on_template,
-        inputs=[prompt],
-        outputs=[code_output, status_output, app_container]
+    stop_btn.click(
+        on_stop,
+        inputs=[running_app_process, running_app_file],
+        outputs=[status_output, app_frame, stop_btn, running_app_process, running_app_file]
     )
 
-# Hello world demo that should work with any Gradio version
-def hello_world():
-    return "Hello, World!"
-
-basic_demo = gr.Interface(
-    fn=hello_world,
-    inputs=None,
-    outputs="text",
-    title="Hello World App"
-)
-
 if __name__ == "__main__":
-    # Use the simplest launch method
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)