Update app.py

app.py

@@ -7,27 +7,27 @@ import tempfile
 import sys
 import json
 import time
-import signal
 import atexit
 
-# Print Python version info for debugging
+# 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_processes = []
+running_process = None
 
-# Clean up any running processes on exit
-def cleanup_processes():
-    for process in running_processes:
+# Clean up running process on exit
+def cleanup_process():
+    global running_process
+    if running_process and running_process.poll() is None:
         try:
-            if process.poll() is None:  # If process is still running
-                process.terminate()
-                process.wait(timeout=5)
-                print(f"Terminated process {process.pid}")
+            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_processes)
+atexit.register(cleanup_process)
 
 def call_openai_api(api_key, prompt):
     """Call OpenAI API to generate Gradio app code and requirements"""
@@ -37,48 +37,39 @@ def call_openai_api(api_key, prompt):
     }
     
     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.
+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.32.0", "numpy", "pandas", ...],
-    "app_name": "descriptive-name-of-app",
+    "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. Include demo.launch(server_name="0.0.0.0", server_port=7861) at the end of the code
-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.32.0 (important: use exactly this version).
-6. Use only gr.Interface instead of gr.Blocks to avoid version compatibility issues.
-7. Don't use any buttons' .click() methods or event handlers - use gr.Interface() only.
-8. Make the app functionality self-contained and robust.
-9. Don't create directories or write to any file paths.
-10. Don't use flagging callbacks or features.
-
-Here's a simple template to follow:
+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
 
-# Define your functions here
-def process_data(input_data):
-    result = input_data * 2  # Simple example
-    return f"Processed: {result}"
+def process(input_value):
+    return input_value * 2
 
-# Create the Gradio interface
 demo = gr.Interface(
-    fn=process_data,
-    inputs=gr.Number(label="Input Data"),
-    outputs=gr.Textbox(label="Result"),
-    title="Data Processor"
+    fn=process,
+    inputs=gr.Number(label="Input"),
+    outputs=gr.Number(label="Output"),
+    title="Number Doubler"
 )
 
-# Launch the app
 demo.launch(server_name="0.0.0.0", server_port=7861)
 ```
 """
@@ -108,25 +99,39 @@ demo.launch(server_name="0.0.0.0", server_port=7861)
         
         # 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
+            # Look for JSON object
+            json_pattern = r'({[\s\S]*})'
+            json_match = re.search(json_pattern, content)
             
-            app_info = json.loads(json_str)
+            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"
+                }
             
-            # Extract Python code if it's wrapped in code blocks
+            # 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"])
@@ -134,136 +139,90 @@ demo.launch(server_name="0.0.0.0", server_port=7861)
                     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'import\s+([a-zA-Z0-9_]+)'
-            req_matches = re.findall(req_pattern, app_code)
-            
-            requirements = ["gradio==3.32.0"]
-            if req_matches:
-                for module in req_matches:
-                    if module != "gradio" and module not in requirements and module != "os" and module != "sys":
-                        requirements.append(module)
-            
-            # Construct a partial app_info
-            app_info = {
-                "app_code": app_code,
-                "requirements": requirements,
-                "app_name": "gradio-app",
-                "description": "Generated Gradio application"
-            }
-            
-            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"Error: {str(e)}"
+        return None, f"API call failed: {str(e)}"
 
-def install_and_run_app(app_code, requirements):
+def install_and_run_app(code, requirements):
     """Install requirements and run the app in a subprocess"""
+    global running_process
+    
     try:
-        # Create a temporary directory for the app
-        temp_dir = tempfile.mkdtemp()
+        # Clean up any previous process
+        if running_process and running_process.poll() is None:
+            running_process.terminate()
+            running_process.wait(timeout=5)
         
-        # Create app file
-        app_file = os.path.join(temp_dir, "app.py")
-        with open(app_file, 'w') as f:
-            f.write(app_code)
+        # Create a temporary file for the app
+        fd, app_file = tempfile.mkstemp(suffix='.py')
+        os.close(fd)
         
-        # Make sure port 7861 is specified
-        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 7861\n")
-                f.write("if 'demo' in locals():\n")
-                f.write("    demo.launch(server_name='0.0.0.0', server_port=7861)\n")
+        with open(app_file, 'w') as f:
+            f.write(code)
         
         # Install requirements
-        pip_output = ""
+        install_output = ""
         for req in requirements:
             try:
-                cmd = [sys.executable, "-m", "pip", "install", req]
-                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-                pip_output += f"Installing {req}: {'SUCCESS' if result.returncode == 0 else 'FAILED'}\n"
+                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:
-                    pip_output += f"Error: {result.stderr}\n"
+                    install_output += f"Error: {result.stderr}\n"
             except Exception as e:
-                pip_output += f"Error installing {req}: {str(e)}\n"
+                install_output += f"Error installing {req}: {str(e)}\n"
         
         # Run the app
-        cmd = [sys.executable, app_file]
-        app_process = subprocess.Popen(
-            cmd, 
-            stdout=subprocess.PIPE, 
+        running_process = subprocess.Popen(
+            [sys.executable, app_file],
+            stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             text=True
         )
         
-        running_processes.append(app_process)
-        
         # Wait a bit for the app to start
-        time.sleep(3)
+        time.sleep(5)
         
         # Check if the process is still running
-        if app_process.poll() is not None:
-            stdout, stderr = app_process.communicate()
-            return None, f"App failed to start:\n{stderr}\n\nInstallation log:\n{pip_output}"
+        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 {
-            "process": app_process,
             "app_file": app_file,
-            "temp_dir": temp_dir,
-            "url": "http://localhost:7861",
-            "pip_output": pip_output
+            "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(app_details):
-    """Stop a running app and clean up"""
-    try:
-        if app_details and "process" in app_details:
-            process = app_details["process"]
-            if process.poll() is None:  # If process is still running
-                process.terminate()
-                try:
-                    process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                
-                if process in running_processes:
-                    running_processes.remove(process)
-        
-        # Clean up temp directory
-        if app_details and "temp_dir" in app_details:
-            import shutil
-            try:
-                shutil.rmtree(app_details["temp_dir"])
-            except:
-                pass
-        
-        return True
-    except Exception as e:
-        print(f"Error stopping app: {str(e)}")
-        return False
+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 within this container. The generated app will be displayed below.
+    and runs it directly. The generated app will be displayed below.
     """)
     
-    # State variable to track running app details
-    app_details_state = gr.State(None)
-    
     with gr.Row():
         with gr.Column(scale=1):
             api_key = gr.Textbox(
@@ -286,8 +245,8 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             with gr.Accordion("Generated Code", open=False):
                 code_output = gr.Code(language="python", label="App Code")
             
-            with gr.Accordion("Package Installation Log", open=False):
-                install_output = gr.Textbox(label="Installation Log", lines=5)
+            with gr.Accordion("Installation Log", open=False):
+                install_output = gr.Textbox(label="Package Installation Log", lines=5)
             
             status_output = gr.Markdown("")
         
@@ -295,11 +254,10 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             # 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_generate(api_key_val, prompt_val, current_app_details):
-        # Stop any previously running app
-        if current_app_details:
-            stop_running_app(current_app_details)
-        
+    # 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 (
@@ -309,7 +267,7 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             )
         
         try:
-            # Call the OpenAI API to generate app code and requirements
+            # Generate app code and requirements
             status_message = "⏳ Generating app code..."
             yield (
                 None, None, status_message, 
@@ -317,18 +275,24 @@ with gr.Blocks(title="Gradio App Generator") as demo:
                 gr.update(visible=False), None
             )
             
-            app_info, api_error = call_openai_api(api_key_val, prompt_val)
-            if api_error or not app_info:
+            app_info, error = call_openai_api(api_key_val, prompt_val)
+            if error or not app_info:
                 return (
-                    None, None, f"⚠️ {api_error or 'Failed to generate app'}",
+                    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
                 )
             
-            # At this point we have app code and requirements
             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,
@@ -337,15 +301,15 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             )
             
             # Install packages and run the app
-            app_details, run_error = install_and_run_app(code, requirements)
-            if run_error or not app_details:
+            run_result, run_error = install_and_run_app(code, requirements)
+            if run_error or not run_result:
                 return (
-                    code, None, f"⚠️ {run_error or 'Failed to run app'}",
+                    code, None, f"⚠️ {run_error}",
                     "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
                     gr.update(visible=False), None
                 )
             
-            # Create iframe to display the app
+            # 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>
@@ -353,10 +317,8 @@ with gr.Blocks(title="Gradio App Generator") as demo:
             """
             
             return (
-                code, app_details["pip_output"], 
-                f"✅ App is running! View it below.", 
-                iframe_html,
-                gr.update(visible=True), app_details
+                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
@@ -367,36 +329,44 @@ with gr.Blocks(title="Gradio App Generator") as demo:
                 gr.update(visible=False), None
             )
     
-    def on_stop(current_app_details):
-        if current_app_details:
-            stopped = stop_running_app(current_app_details)
-            if stopped:
-                return (
-                    "✅ App stopped successfully", 
-                    "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
-                    gr.update(visible=False), None
-                )
+    def on_stop(app_file):
+        stopped = stop_running_app()
         
-        return (
-            "⚠️ No app was running", 
-            "<div style='text-align:center; padding:50px;'><h3>No app was running</h3></div>",
-            gr.update(visible=False), None
-        )
+        # 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, app_details_state],
+        inputs=[api_key, prompt],
         outputs=[
             code_output, install_output, status_output, app_frame, 
-            stop_btn, app_details_state
+            stop_btn, app_file_state
         ]
     )
     
     stop_btn.click(
         on_stop,
-        inputs=[app_details_state],
-        outputs=[status_output, app_frame, stop_btn, app_details_state]
+        inputs=[app_file_state],
+        outputs=[status_output, app_frame, stop_btn, app_file_state]
     )
 
 if __name__ == "__main__":
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860)
+    # Make sure we're not trying to use flagging
+    demo.launch(server_name="0.0.0.0", server_port=7860, flagging_callback=None)