Update app.py

app.py

@@ -7,60 +7,17 @@ import tempfile
 import sys
 import json
 import time
-import threading
-import queue
-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 and resources for cleanup
+# Track running processes and files
 running_process = None
-temp_files = []
-
-# Clean up resources on exit
-def cleanup_resources():
-    global running_process, temp_files
-    # Stop any 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}")
-    
-    # Remove temporary files
-    for file_path in temp_files:
-        if os.path.exists(file_path):
-            try:
-                os.unlink(file_path)
-                print(f"Removed temporary file: {file_path}")
-            except Exception as e:
-                print(f"Error removing file {file_path}: {e}")
-
-atexit.register(cleanup_resources)
-
-# Queue for capturing subprocess output
-output_queue = queue.Queue()
-
-def read_output(process, output_queue):
-    """Read output from a process and put it in a queue"""
-    for line in iter(process.stdout.readline, ''):
-        if line:
-            output_queue.put(line)
-    process.stdout.close()
-
-def read_error(process, output_queue):
-    """Read error output from a process and put it in a queue"""
-    for line in iter(process.stderr.readline, ''):
-        if line:
-            output_queue.put(f"ERROR: {line}")
-    process.stderr.close()
+temp_file = None
 
 def call_openai_api(api_key, prompt):
-    """Call OpenAI API to generate Gradio app code and requirements"""
+    """Call OpenAI API to generate Gradio app code"""
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {api_key}"
@@ -69,22 +26,13 @@ def call_openai_api(api_key, prompt):
     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": [],
-    "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. DO NOT include any requirements - use ONLY packages that are already included with Gradio
-5. Keep the app simple and focused on the user's request - NO extra package dependencies
-6. DO NOT use any flagging callbacks or flagging_dir parameters in launch
-7. DO NOT create or use any directories or file paths
-8. Only use basic Python libraries and features from Gradio and its default dependencies
+1. Use ONLY gr.Interface (NOT gr.Blocks)
+2. Always include server_name="0.0.0.0" and server_port=7861 in the launch parameters
+3. Keep the app simple and focused on the user's request
+4. DO NOT use any flagging callbacks or flagging_dir parameters
+5. Use only standard Python libraries that come with Python
+6. Try to use the simplest possible implementation
 
 Example:
 ```python
@@ -105,21 +53,19 @@ 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
+            json={
+                "model": "gpt-4o",
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": 0.2,
+                "max_tokens": 4000
+            }
         )
         
         if response.status_code != 200:
@@ -128,298 +74,183 @@ demo.launch(server_name="0.0.0.0", server_port=7861)
         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)
-                
-                # For simplicity, we're going to avoid additional requirements
-                app_info = {
-                    "app_code": code,
-                    "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)}"
+        # Extract code from the response
+        code_pattern = r'```python\s*([\s\S]*?)```'
+        code_match = re.search(code_pattern, content)
+        
+        if code_match:
+            return code_match.group(1), None
+        else:
+            # If no code block found, use the entire content
+            return content, None
     except Exception as e:
         return None, f"API call failed: {str(e)}"
 
-def run_app(app_code, output_queue):
-    """Run the app in a separate process"""
-    global running_process, temp_files
+def run_app(code):
+    """Run the Gradio app in a subprocess"""
+    global running_process, temp_file
     
-    # Stop any existing process
+    # Stop any previously running process
     if running_process and running_process.poll() is None:
         running_process.terminate()
-        try:
-            running_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
+        time.sleep(1)
+        if running_process.poll() is None:
             running_process.kill()
     
+    # Clean up previous temp file
+    if temp_file and os.path.exists(temp_file):
+        try:
+            os.unlink(temp_file)
+        except:
+            pass
+    
     # Create a temporary file for the app
-    fd, app_file = tempfile.mkstemp(suffix='.py')
+    fd, temp_file = tempfile.mkstemp(suffix='.py')
     os.close(fd)
     
-    with open(app_file, 'w') as f:
-        f.write(app_code)
-    
-    temp_files.append(app_file)
-    
-    # Make sure the code has the correct launch parameters
-    with open(app_file, 'r') as f:
-        app_code = f.read()
-    
-    # Remove flagging_callback if present
-    app_code = re.sub(r'flagging_callback\s*=\s*[^,)]+', '', app_code)
+    # Make sure launch parameters are correct
+    if "server_name" not in code or "server_port" not in code:
+        code += "\n\ndemo.launch(server_name='0.0.0.0', server_port=7861)\n"
     
-    # Remove flagging_dir if present
-    app_code = re.sub(r'flagging_dir\s*=\s*[^,)]+', '', app_code)
+    # Remove any flagging parameters
+    code = code.replace("flagging_callback", "#flagging_callback")
+    code = code.replace("flagging_dir", "#flagging_dir")
     
-    # Make sure it has the correct launch parameters
-    if "demo.launch" not in app_code:
-        app_code += "\n\ndemo.launch(server_name='0.0.0.0', server_port=7861)\n"
-    elif "server_name" not in app_code or "server_port" not in app_code:
-        app_code = re.sub(r'demo\.launch\s*\(', r'demo.launch(server_name="0.0.0.0", server_port=7861, ', app_code)
-    
-    # Write the updated code back to the file
-    with open(app_file, 'w') as f:
-        f.write(app_code)
+    # Write the code to the file
+    with open(temp_file, 'w') as f:
+        f.write(code)
     
     # Run the app
-    output_queue.put(f"Starting the app...\n")
-    running_process = subprocess.Popen(
-        [sys.executable, app_file],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=1
-    )
-    
-    # Start threads to read output
-    stdout_thread = threading.Thread(target=read_output, args=(running_process, output_queue))
-    stderr_thread = threading.Thread(target=read_error, args=(running_process, output_queue))
-    
-    stdout_thread.daemon = True
-    stderr_thread.daemon = True
+    try:
+        running_process = subprocess.Popen(
+            [sys.executable, temp_file],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        # Wait for the app to start
+        time.sleep(3)
+        
+        # Check if the process is still running
+        if running_process.poll() is not None:
+            stdout, stderr = running_process.communicate()
+            return False, f"App failed to start:\n{stderr.decode('utf-8')}"
+        
+        return True, None
+    except Exception as e:
+        return False, f"Error starting app: {str(e)}"
+
+# Create a minimal Gradio interface
+with gr.Blocks(title="Simple Gradio App Generator") as demo:
+    gr.Markdown("# 🤖 Gradio App Generator")
+    gr.Markdown("Enter a description of the app you want to create.")
     
-    stdout_thread.start()
-    stderr_thread.start()
+    api_key = gr.Textbox(
+        label="OpenAI API Key", 
+        placeholder="sk-...",
+        type="password"
+    )
     
-    # Wait a bit for the app to start
-    time.sleep(5)
+    prompt = gr.Textbox(
+        label="App Description", 
+        placeholder="Describe the Gradio app you want to create...",
+        lines=3
+    )
     
-    # Check if the process is still running
-    if running_process.poll() is not None:
-        output_queue.put(f"App failed to start (error code: {running_process.returncode})\n")
-        return False, app_file
+    with gr.Row():
+        generate_btn = gr.Button("Generate & Run App", variant="primary")
+        stop_btn = gr.Button("Stop App", variant="stop", visible=False)
     
-    output_queue.put(f"App is running on port 7861\n")
-    return True, app_file
-
-# 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 directly with no additional dependencies. The generated app will be displayed below.
-    """)
+    code_output = gr.Code(
+        language="python",
+        label="Generated Code",
+        lines=10
+    )
     
-    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")
-            
-            progress_output = gr.Textbox(
-                label="Progress Log", 
-                lines=10,
-                max_lines=20,
-                interactive=False
-            )
-            
-            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>")
+    status_output = gr.Markdown("")
     
-    # App file storage
-    app_file_state = gr.State(None)
+    app_frame = gr.HTML(
+        "<div style='text-align:center; padding:50px;'><h3>Your app will appear here</h3></div>"
+    )
     
-    def on_generate(api_key_val, prompt_val):
-        # Initialize output queue
-        global output_queue
-        output_queue = queue.Queue()
-        
-        # Validate API key
-        if not api_key_val or len(api_key_val) < 20 or not api_key_val.startswith("sk-"):
+    def on_generate(key, description):
+        """Generate and run the app"""
+        if not key or len(key) < 20 or not key.startswith("sk-"):
             return (
-                None, "⚠️ Please provide a valid OpenAI API key", 
+                None, 
+                "⚠️ Please provide a valid OpenAI API key",
                 "<div style='text-align:center; padding:50px;'><h3>Invalid API key</h3></div>",
-                "Please enter a valid OpenAI API key",
-                gr.update(visible=False), None
+                gr.update(visible=False)
             )
         
-        try:
-            # Generate app code and requirements
-            status_message = "⏳ Generating app code..."
-            yield (
-                None, status_message, 
-                "<div style='text-align:center; padding:50px;'><h3>Generating code...</h3></div>",
-                "Generating app code...",
-                gr.update(visible=False), None
-            )
-            
-            app_info, error = call_openai_api(api_key_val, prompt_val)
-            if error or not app_info:
-                return (
-                    None, f"⚠️ {error or 'Failed to generate app'}", 
-                    "<div style='text-align:center; padding:50px;'><h3>Error generating app</h3></div>",
-                    f"Error: {error or 'Failed to generate app'}",
-                    gr.update(visible=False), None
-                )
-            
-            code = app_info["app_code"]
-            
-            # 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 = "⏳ Starting the app..."
-            yield (
-                code, status_message,
-                "<div style='text-align:center; padding:50px;'><h3>Starting app...</h3></div>",
-                "Starting the app...",
-                gr.update(visible=False), None
-            )
-            
-            # Run the app
-            success, app_file = run_app(code, output_queue)
-            
-            # Update the progress output
-            progress_text = ""
-            while not output_queue.empty():
-                progress_text += output_queue.get_nowait()
-            
-            if not success:
-                return (
-                    code, "⚠️ Failed to start the app",
-                    "<div style='text-align:center; padding:50px;'><h3>Error starting app</h3></div>",
-                    progress_text,
-                    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>
-            """
-            
+        # Generate the code
+        code, error = call_openai_api(key, description)
+        if error or not code:
             return (
-                code, f"✅ App is running! View it below.", 
-                iframe_html,
-                progress_text,
-                gr.update(visible=True), app_file
+                None,
+                f"⚠️ Error: {error or 'Failed to generate code'}",
+                "<div style='text-align:center; padding:50px;'><h3>Error generating code</h3></div>",
+                gr.update(visible=False)
             )
-        except Exception as e:
-            import traceback
-            error_details = traceback.format_exc()
+        
+        # Run the app
+        success, run_error = run_app(code)
+        if not success:
             return (
-                None, f"⚠️ Error: {str(e)}",
-                "<div style='text-align:center; padding:50px;'><h3>An error occurred</h3></div>",
-                f"Error: {str(e)}\n\n{error_details}",
-                gr.update(visible=False), None
+                code,
+                f"⚠️ Error: {run_error}",
+                "<div style='text-align:center; padding:50px;'><h3>Error running app</h3></div>",
+                gr.update(visible=False)
             )
+        
+        # Create an iframe to display the app
+        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,
+            "✅ App is running! View it below.",
+            iframe_html,
+            gr.update(visible=True)
+        )
     
-    def on_stop(app_file):
-        global running_process
+    def on_stop():
+        """Stop the running app"""
+        global running_process, temp_file
         
         if running_process and running_process.poll() is None:
             running_process.terminate()
-            try:
-                running_process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
+            time.sleep(1)
+            if running_process.poll() is None:
                 running_process.kill()
-            
-            running_process = None
         
-        # Clean up the app file
-        if app_file and os.path.exists(app_file):
+        if temp_file and os.path.exists(temp_file):
             try:
-                os.unlink(app_file)
-                if app_file in temp_files:
-                    temp_files.remove(app_file)
+                os.unlink(temp_file)
             except:
                 pass
         
         return (
-            "✅ App stopped", 
+            "✅ App stopped",
             "<div style='text-align:center; padding:50px;'><h3>App stopped</h3></div>",
-            "App has been stopped",
-            gr.update(visible=False), None
+            gr.update(visible=False)
         )
     
     generate_btn.click(
         on_generate,
         inputs=[api_key, prompt],
-        outputs=[
-            code_output, status_output, app_frame, 
-            progress_output, stop_btn, app_file_state
-        ]
+        outputs=[code_output, status_output, app_frame, stop_btn]
     )
     
     stop_btn.click(
         on_stop,
-        inputs=[app_file_state],
-        outputs=[
-            status_output, app_frame, progress_output,
-            stop_btn, app_file_state
-        ]
+        inputs=[],
+        outputs=[status_output, app_frame, stop_btn]
     )
 
 if __name__ == "__main__":
-    # Launch without any optional parameters that might cause issues
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860)
+    # Launch with minimal parameters
+    demo.launch(server_name="0.0.0.0", server_port=7860)