Update app.py

app.py

@@ -7,97 +7,204 @@ import sys
 import os
 import ast
 import traceback
+from types import MethodType
 
-# Determine Gradio version
+# Check Gradio version
 GRADIO_VERSION = gr.__version__
-MAJOR_VERSION = int(GRADIO_VERSION.split('.')[0])
+print(f"Gradio version: {GRADIO_VERSION}")
 
-def call_openai_api(api_key, prompt, error_feedback=None, attempt=1):
-    """Direct API call to OpenAI with auto-fixing based on errors"""
+# Patch Gradio Button class if needed
+if not hasattr(gr.Button, 'click'):
+    # For Gradio 4.x, we need to add a click method
+    def patched_click(self, fn, inputs=None, outputs=None):
+        """Patched click method for Gradio 4.x buttons"""
+        if inputs is None:
+            inputs = []
+        if outputs is None:
+            outputs = []
+        
+        # In Gradio 4.x, this would be the event listener pattern
+        return self.click(fn=fn, inputs=inputs, outputs=outputs)
+    
+    # Try to add the method, might not work but worth a try
+    try:
+        gr.Button.click = patched_click
+        print("Added click method to Button class")
+    except Exception as e:
+        print(f"Failed to patch Button class: {e}")
+
+# Function to generate working code for the current Gradio version
+def generate_compatible_code(prompt):
+    """Generate code that's guaranteed to work with this Gradio version"""
+    if "hello world" in prompt.lower():
+        return """
+import gradio as gr
+
+# Creating a simple hello world app that works in all Gradio versions
+def say_hello():
+    return "Hello, World!"
+
+# Create the Gradio interface
+demo = gr.Interface(
+    fn=say_hello,
+    inputs=[],
+    outputs=gr.Textbox(label="Output"),
+    title="Hello World App"
+)
+"""
+    elif "calculator" in prompt.lower():
+        return """
+import gradio as gr
+import numpy as np
+
+# Create a simple calculator
+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"
+
+# Create the Gradio interface - works in all versions
+demo = gr.Interface(
+    fn=calculate,
+    inputs=[
+        gr.Number(label="First Number"),
+        gr.Number(label="Second Number"),
+        gr.Dropdown(["Add", "Subtract", "Multiply", "Divide"], label="Operation")
+    ],
+    outputs=gr.Number(label="Result"),
+    title="Simple Calculator"
+)
+"""
+    elif "image" in prompt.lower() or "filter" in prompt.lower():
+        return """
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageEnhance
+
+# Create an image brightness adjuster
+def adjust_brightness(image, brightness_factor):
+    if image is None:
+        return None
+    
+    # Convert to PIL Image
+    pil_image = Image.fromarray(image)
+    
+    # Adjust brightness
+    enhancer = ImageEnhance.Brightness(pil_image)
+    brightened = enhancer.enhance(brightness_factor)
+    
+    # Return as numpy array
+    return np.array(brightened)
+
+# Create the Gradio interface - works in all versions
+demo = gr.Interface(
+    fn=adjust_brightness,
+    inputs=[
+        gr.Image(label="Input Image"),
+        gr.Slider(0.1, 3.0, 1.0, label="Brightness Factor")
+    ],
+    outputs=gr.Image(label="Adjusted Image"),
+    title="Image Brightness Adjuster"
+)
+"""
+    elif "text" in prompt.lower() or "sentiment" in prompt.lower():
+        return """
+import gradio as gr
+import random
+
+# Simple sentiment analyzer (mock)
+def analyze_sentiment(text):
+    if not text:
+        return "Please enter some text"
+    
+    # Calculate length and random sentiment for demo
+    text_length = len(text)
+    sentiment = random.choice(["Positive", "Neutral", "Negative"])
+    
+    return f"Length: {text_length} characters | Sentiment: {sentiment}"
+
+# Create the Gradio interface - works in all versions
+demo = gr.Interface(
+    fn=analyze_sentiment,
+    inputs=gr.Textbox(lines=5, label="Enter text here"),
+    outputs=gr.Textbox(label="Analysis Result"),
+    title="Text Analyzer"
+)
+"""
+    else:
+        return """
+import gradio as gr
+
+# A general purpose demo that works in all Gradio versions
+def process_input(text_input):
+    if not text_input:
+        return "Please enter some input"
+    
+    # Process the input
+    word_count = len(text_input.split())
+    char_count = len(text_input)
+    
+    return f"Word count: {word_count} | Character count: {char_count}"
+
+# Create the Gradio interface - works in all versions
+demo = gr.Interface(
+    fn=process_input,
+    inputs=gr.Textbox(lines=3, label="Input"),
+    outputs=gr.Textbox(label="Output"),
+    title="Text Processor"
+)
+"""
+
+def call_openai_api(api_key, prompt):
+    """Direct API call to OpenAI"""
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {api_key}"
     }
     
+    # Create a system prompt specifically for gr.Interface() style apps
     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 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
+IMPORTANT: You MUST use gr.Interface() instead of gr.Blocks() for compatibility.
+DO NOT use Button.click() or any other component events.
 
-   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
+Here's a template to follow:
+```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
-3. DO NOT include a launch command or if __name__ == "__main__" block
-4. The interface should be assigned to a variable named 'demo'
-5. Handle errors gracefully
-6. Be completely self-contained in a single script
-7. Make sure all variables are properly defined before use
-"""
+def my_function(input1, input2):
+    # Process inputs
+    result = input1 + input2  # Example operation
+    return result
 
-    # 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}
+# Create the Gradio interface
+demo = gr.Interface(
+    fn=my_function,
+    inputs=[gr.Textbox(label="Input 1"), gr.Textbox(label="Input 2")],
+    outputs=gr.Textbox(label="Output"),
+    title="My App"
+)
 ```
 
-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
+The code must:
+1. Import necessary libraries
+2. Define functions that handle the app logic
+3. Create a gr.Interface named 'demo'
+4. NOT include a launch command or if __name__ == "__main__" block
+5. Avoid using component events or callbacks
 """
-
+    
     data = {
         "model": "gpt-4o",
         "messages": [
@@ -131,32 +238,6 @@ def extract_code_blocks(text):
     
     return [match.strip() for match in matches]
 
-def validate_gradio_code(code):
-    """Basic validation of the generated code"""
-    try:
-        tree = ast.parse(code)
-        
-        allowed_modules = ['gradio', 'numpy', 'pandas', 'matplotlib', 'PIL', 'os', 'io', 'base64', 
-                          'time', 'datetime', 'json', 'random', 'math', 'sys', 're', 'pathlib',
-                          'collections', 'typing', 'warnings']
-        
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Import):
-                for name in node.names:
-                    if name.name not in allowed_modules:
-                        return False, f"Unauthorized import: {name.name}"
-            
-            elif isinstance(node, ast.ImportFrom):
-                if node.module not in allowed_modules and node.module is not None:
-                    return False, f"Unauthorized import from: {node.module}"
-        
-        return True, None
-        
-    except SyntaxError as e:
-        return False, f"Syntax error in the code: {str(e)}"
-    except Exception as e:
-        return False, f"Error validating code: {str(e)}"
-
 def load_generated_app(code):
     """Load and run the generated Gradio app"""
     # Save code to temp file
@@ -187,81 +268,10 @@ def load_generated_app(code):
         except:
             pass
 
-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
-    
-    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
-        )
-        
-        if api_error:
-            return None, api_error, attempt
-        
-        # 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(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.")
+    gr.Markdown("Describe the Gradio app you want, and I'll generate it for you.")
     
     with gr.Row():
         with gr.Column():
@@ -278,88 +288,88 @@ with gr.Blocks(title="AI Gradio App Generator") as demo:
                 lines=5
             )
             
-            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")
+                skip_api_btn = gr.Button("Try Without API", variant="secondary")
             
             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, max_attempts_value):
+    def on_submit(api_key_input, prompt_text):
         # 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)
+            return None, "⚠️ Please provide a valid OpenAI API key", gr.update(visible=False)
         
         try:
-            # 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
+            response, api_error = call_openai_api(api_key_input, prompt_text)
+            if api_error:
+                return None, f"⚠️ {api_error}", gr.update(visible=False)
             
-            attempt_msg = f"Generation attempt {attempt}/{max_attempts_value}"
+            # Extract code blocks
+            code_blocks = extract_code_blocks(response)
+            if not code_blocks:
+                return None, "⚠️ No valid code found in the response", gr.update(visible=False)
             
-            if code is None:
-                return None, f"⚠️ {result}", gr.update(visible=False), gr.update(visible=True, value=attempt_msg)
+            code = code_blocks[0]
             
-            if isinstance(result, str):  # Error message
-                return code, f"⚠️ {result}", gr.update(visible=False), gr.update(visible=True, value=attempt_msg)
-            
-            # Success - result is the app
-            success_msg = "✅ App generated successfully!"
-            if attempt > 1:
-                success_msg += f" (fixed after {attempt} attempts)"
+            # Try to load the app
+            app, load_error = load_generated_app(code)
+            if load_error:
+                # If there's an error, fallback to built-in templates
+                fallback_code = generate_compatible_code(prompt_text)
+                app, fallback_error = load_generated_app(fallback_code)
+                
+                if fallback_error:
+                    return fallback_code, f"⚠️ Error loading app: {fallback_error}", gr.update(visible=False)
                 
-            return code, success_msg, gr.update(visible=True, value=result), gr.update(visible=True, value=attempt_msg)
+                return fallback_code, "✅ App generated from template (API generation failed)", gr.update(visible=True, value=app)
+            
+            # Success!
+            return code, "✅ App generated successfully!", gr.update(visible=True, value=app)
             
         except Exception as e:
             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!"
+            
+            # Try fallback
+            try:
+                fallback_code = generate_compatible_code(prompt_text)
+                app, fallback_error = load_generated_app(fallback_code)
+                
+                if fallback_error:
+                    return None, f"⚠️ Error: {str(e)}\n\nFallback also failed: {fallback_error}", gr.update(visible=False)
+                
+                return fallback_code, "✅ App generated from template (after error recovery)", gr.update(visible=True, value=app)
+            except:
+                return None, f"⚠️ Error: {str(e)}\n{error_details}", gr.update(visible=False)
     
-    # This syntax works for Gradio {0}.x
-    hello_btn.click(fn=say_hello, inputs=None, outputs=output)
-""".format(MAJOR_VERSION)
+    def on_skip_api():
+        """Generate an app without using the API"""
+        app_code = generate_compatible_code(prompt.value)
         
-        return hello_code, "✅ Hello World example shown below!", gr.update(visible=True, value=hello_app), gr.update(visible=False)
+        try:
+            app, error = load_generated_app(app_code)
+            if error:
+                return app_code, f"⚠️ Error loading template: {error}", gr.update(visible=False)
+            
+            return app_code, "✅ App generated from built-in template", gr.update(visible=True, value=app)
+        except Exception as e:
+            return app_code, f"⚠️ Error: {str(e)}", gr.update(visible=False)
     
     submit_btn.click(
         on_submit,
-        inputs=[api_key, prompt, max_attempts],
-        outputs=[code_output, status_output, generated_app_container, attempt_output]
+        inputs=[api_key, prompt],
+        outputs=[code_output, status_output, generated_app_container]
     )
     
-    hello_world_btn.click(
-        on_hello_world,
+    skip_api_btn.click(
+        on_skip_api,
         inputs=[],
-        outputs=[code_output, status_output, generated_app_container, attempt_output]
+        outputs=[code_output, status_output, generated_app_container]
     )
 
 if __name__ == "__main__":