Update app.py

app.py

@@ -6,26 +6,73 @@ import importlib.util
 import sys
 import os
 import ast
+import traceback
 
-def call_openai_api(api_key, prompt):
-    """Direct API call to OpenAI"""
+# Determine Gradio version
+GRADIO_VERSION = gr.__version__
+MAJOR_VERSION = int(GRADIO_VERSION.split('.')[0])
+
+def call_openai_api(api_key, prompt, error_feedback=None, attempt=1):
+    """Direct API call to OpenAI with auto-fixing based on errors"""
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {api_key}"
     }
     
-    # Determine Gradio version to ensure compatibility
-    gradio_version = gr.__version__
-    major_version = int(gradio_version.split('.')[0])
-    
     system_prompt = f"""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.
 
-IMPORTANT: You must use Gradio version {gradio_version} (Gradio {major_version}.x) syntax.
-For Gradio 3.x: Use the `.click()` method on buttons and elements to connect them to functions.
-For Gradio 4.x: Use the event subscription pattern instead of .click().
+IMPORTANT: You must use Gradio version {GRADIO_VERSION} (Gradio {MAJOR_VERSION}.x) syntax correctly.
+"""
+    
+    # Add version-specific instructions based on actual Gradio version
+    if MAJOR_VERSION >= 4:
+        system_prompt += """
+For Gradio 4.x:
+1. DO NOT use component methods like `.click()`, `.submit()`, or `.change()`
+2. Instead use event listeners in the form:
+   ```python
+   def my_function(inputs):
+       return outputs
+       
+   button.click(fn=my_function, inputs=input_components, outputs=output_components)
+   ```
+3. Example hello world app for Gradio 4.x:
+   ```python
+   import gradio as gr
 
+   with gr.Blocks() as demo:
+       hello_btn = gr.Button("Say Hello")
+       output = gr.Textbox(label="Output")
+       
+       def say_hello():
+           return "Hello, World!"
+       
+       hello_btn.click(fn=say_hello, inputs=None, outputs=output)
+   ```
+"""
+    else:
+        system_prompt += """
+For Gradio 3.x:
+1. Use component methods like `.click()`, `.submit()`, or `.change()`
+2. Example hello world app for Gradio 3.x:
+   ```python
+   import gradio as gr
+
+   def say_hello():
+       return "Hello, World!"
+   
+   with gr.Blocks() as demo:
+       hello_btn = gr.Button("Say Hello")
+       output = gr.Textbox(label="Output")
+       
+       hello_btn.click(fn=say_hello, inputs=None, outputs=output)
+   ```
+"""
+    
+    # Add the specific requirements for the code
+    system_prompt += """
 The code must:
 1. Import all necessary libraries
 2. Define a complete, functional Gradio interface
@@ -34,24 +81,23 @@ The code must:
 5. Handle errors gracefully
 6. Be completely self-contained in a single script
 7. Make sure all variables are properly defined before use
-8. Use simple input/output types that are well-supported (text, numbers, images)
-
-Example for Gradio 3.x:
-```python
-import gradio as gr
-
-def greet(name_input):
-    return f"Hello, {{name_input}}!"
+"""
 
-with gr.Blocks() as demo:
-    name_input = gr.Textbox(label="Your Name")
-    greet_btn = gr.Button("Greet")
-    output = gr.Textbox(label="Output")
-    
-    greet_btn.click(fn=greet, inputs=name_input, outputs=output)
+    # Add error feedback for auto-fixing
+    if error_feedback and attempt > 1:
+        system_prompt += f"""
+IMPORTANT: Previous code generated an error. Fix the code to avoid this error:
+```
+{error_feedback}
 ```
+
+Fix these common issues:
+- If error mentions 'object has no attribute click/change/submit', make sure you're using the correct event syntax for Gradio {MAJOR_VERSION}.x
+- For NameError, ensure all variables are defined before use
+- For ImportError, check that you only use standard libraries
+- For AttributeError, verify component properties and methods
 """
-    
+
     data = {
         "model": "gpt-4o",
         "messages": [
@@ -133,86 +179,89 @@ def load_generated_app(code):
             return None, "No 'demo' variable found in the generated code"
             
     except Exception as e:
-        return None, f"Error: {str(e)}"
+        error_details = traceback.format_exc()
+        return None, f"{str(e)}\n{error_details}"
     finally:
         try:
             os.unlink(temp_file)
         except:
             pass
 
-def generate_app(api_key, prompt):
-    """Main function to generate and load a Gradio app"""
-    # Validate API key format
-    if not api_key or len(api_key) < 20 or not api_key.startswith("sk-"):
-        return None, "Please provide a valid OpenAI API key"
-    
-    # Call OpenAI API
-    response, error = call_openai_api(api_key, prompt)
-    if error:
-        return None, error
-    
-    # Extract code blocks
-    code_blocks = extract_code_blocks(response)
-    if not code_blocks:
-        return None, "No valid code found in the response"
+def generate_app_with_retries(api_key, prompt, max_attempts=3):
+    """Generate app with automatic error fixing and retries"""
+    last_code = None
+    error_feedback = None
     
-    code = code_blocks[0]
-    
-    # Validate code
-    is_valid, error_msg = validate_gradio_code(code)
-    if not is_valid:
-        return code, error_msg
-    
-    # Load the app
-    app, app_error = load_generated_app(code)
-    if app_error:
-        return code, app_error
-    
-    return code, app
-
-# Simple calculator app for Gradio 3.x
-def calculator_app():
-    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
-        else:
-            return "Please select an operation"
-
-    with gr.Blocks() as demo:
-        gr.Markdown("# Simple Calculator")
-        
-        with gr.Row():
-            num1_input = gr.Number(label="First Number")
-            num2_input = gr.Number(label="Second Number")
-            
-        op_dropdown = gr.Dropdown(
-            ["Add", "Subtract", "Multiply", "Divide"], 
-            label="Operation"
+    for attempt in range(1, max_attempts + 1):
+        # Call OpenAI API with error feedback if available
+        response, api_error = call_openai_api(
+            api_key, 
+            prompt, 
+            error_feedback=error_feedback, 
+            attempt=attempt
         )
         
-        calculate_btn = gr.Button("Calculate")
-        result = gr.Number(label="Result")
+        if api_error:
+            return None, api_error, attempt
         
-        calculate_btn.click(
-            fn=calculate,
-            inputs=[num1_input, num2_input, op_dropdown],
-            outputs=result
-        )
+        # Extract code blocks
+        code_blocks = extract_code_blocks(response)
+        if not code_blocks:
+            return None, "No valid code found in the response", attempt
+        
+        code = code_blocks[0]
+        last_code = code
+        
+        # Validate code
+        is_valid, validation_error = validate_gradio_code(code)
+        if not is_valid:
+            error_feedback = validation_error
+            continue
+        
+        # Try to load the app
+        app, load_error = load_generated_app(code)
+        if load_error:
+            error_feedback = load_error
+            continue
+        
+        # Success!
+        return code, app, attempt
+    
+    # If we've exhausted all attempts, return the last code and error
+    return last_code, error_feedback, max_attempts
+
+# Default hello world apps for different Gradio versions
+def get_hello_world_app():
+    """Return a hello world app appropriate for the installed Gradio version"""
+    if MAJOR_VERSION >= 4:
+        # Gradio 4.x hello world
+        with gr.Blocks() as demo:
+            with gr.Row():
+                hello_btn = gr.Button("Say Hello")
+            
+            output = gr.Textbox(label="Output")
+            
+            def say_hello():
+                return "Hello, World!"
+            
+            hello_btn.click(fn=say_hello, inputs=None, outputs=output)
+    else:
+        # Gradio 3.x hello world
+        with gr.Blocks() as demo:
+            hello_btn = gr.Button("Say Hello")
+            output = gr.Textbox(label="Output")
+            
+            def say_hello():
+                return "Hello, World!"
+            
+            hello_btn.click(fn=say_hello, inputs=None, outputs=output)
     
     return demo
 
 # Create the main UI
 with gr.Blocks(title="AI Gradio App Generator") as demo:
-    gr.Markdown("# 🤖 AI Gradio App Generator")
-    gr.Markdown("Describe the Gradio app you want, and I'll generate it using OpenAI's API.")
+    gr.Markdown(f"# 🤖 AI Gradio App Generator (v{GRADIO_VERSION})")
+    gr.Markdown("Describe the Gradio app you want, and I'll generate it using OpenAI's API with automatic error fixing.")
     
     with gr.Row():
         with gr.Column():
@@ -229,45 +278,88 @@ with gr.Blocks(title="AI Gradio App Generator") as demo:
                 lines=5
             )
             
-            submit_btn = gr.Button("Generate App", variant="primary")
+            max_attempts = gr.Slider(
+                minimum=1, 
+                maximum=5, 
+                value=3, 
+                step=1, 
+                label="Maximum Fix Attempts",
+                info="Number of attempts to fix errors automatically"
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Generate App", variant="primary")
+                hello_world_btn = gr.Button("Hello World Example")
             
             with gr.Accordion("Generated Code", open=False):
                 code_output = gr.Code(language="python", label="Generated Code")
             
             status_output = gr.Markdown("")
+            attempt_output = gr.Markdown(visible=False)
     
     generated_app_container = gr.Group(visible=False)
     
-    def on_submit(api_key_input, prompt_text):
+    def on_submit(api_key_input, prompt_text, max_attempts_value):
+        # Validate API key format
+        if not api_key_input or len(api_key_input) < 20 or not api_key_input.startswith("sk-"):
+            return None, "⚠️ Please provide a valid OpenAI API key", gr.update(visible=False), gr.update(visible=False)
+        
         try:
-            # If it's a simple request for a calculator app, use our built-in example
-            lower_prompt = prompt_text.lower()
-            if "calculator" in lower_prompt:
-                try:
-                    app = calculator_app()
-                    code = "# Using built-in calculator template"
-                    return code, "✅ App generated from template!", gr.update(visible=True, value=app)
-                except Exception as e:
-                    pass  # Fall back to API generation if template fails
+            # Generate custom app via API with auto-fixing
+            code, result, attempt = generate_app_with_retries(
+                api_key_input, 
+                prompt_text,
+                max_attempts=int(max_attempts_value)
+            )
             
-            # Generate custom app via API
-            code, result = generate_app(api_key_input, prompt_text)
+            attempt_msg = f"Generation attempt {attempt}/{max_attempts_value}"
             
             if code is None:
-                return None, f"⚠️ {result}", gr.update(visible=False)
+                return None, f"⚠️ {result}", gr.update(visible=False), gr.update(visible=True, value=attempt_msg)
             
             if isinstance(result, str):  # Error message
-                return code, f"⚠️ {result}", gr.update(visible=False)
+                return code, f"⚠️ {result}", gr.update(visible=False), gr.update(visible=True, value=attempt_msg)
             
             # Success - result is the app
-            return code, "✅ App generated successfully!", gr.update(visible=True, value=result)
+            success_msg = "✅ App generated successfully!"
+            if attempt > 1:
+                success_msg += f" (fixed after {attempt} attempts)"
+                
+            return code, success_msg, gr.update(visible=True, value=result), gr.update(visible=True, value=attempt_msg)
+            
         except Exception as e:
-            return None, f"⚠️ Error: {str(e)}", gr.update(visible=False)
+            error_details = traceback.format_exc()
+            return None, f"⚠️ Error: {str(e)}\n{error_details}", gr.update(visible=False), gr.update(visible=False)
+    
+    def on_hello_world():
+        """Show a basic hello world example that works with the installed Gradio version"""
+        hello_app = get_hello_world_app()
+        hello_code = """
+import gradio as gr
+
+with gr.Blocks() as demo:
+    hello_btn = gr.Button("Say Hello")
+    output = gr.Textbox(label="Output")
+    
+    def say_hello():
+        return "Hello, World!"
+    
+    # This syntax works for Gradio {0}.x
+    hello_btn.click(fn=say_hello, inputs=None, outputs=output)
+""".format(MAJOR_VERSION)
+        
+        return hello_code, "✅ Hello World example shown below!", gr.update(visible=True, value=hello_app), gr.update(visible=False)
     
     submit_btn.click(
         on_submit,
-        inputs=[api_key, prompt],
-        outputs=[code_output, status_output, generated_app_container]
+        inputs=[api_key, prompt, max_attempts],
+        outputs=[code_output, status_output, generated_app_container, attempt_output]
+    )
+    
+    hello_world_btn.click(
+        on_hello_world,
+        inputs=[],
+        outputs=[code_output, status_output, generated_app_container, attempt_output]
     )
 
 if __name__ == "__main__":