Update app.py

app.py

@@ -5,204 +5,109 @@ import tempfile
 import importlib.util
 import sys
 import os
-import ast
 import traceback
-from types import MethodType
 
-# Check Gradio version
+# Print Gradio version for debugging
 GRADIO_VERSION = gr.__version__
-print(f"Gradio version: {GRADIO_VERSION}")
+print(f"Using Gradio version: {GRADIO_VERSION}")
 
-# 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 """
+# Minimal hardcoded apps that should work with any Gradio version
+HELLO_WORLD_APP = """
 import gradio as gr
 
-# Creating a simple hello world app that works in all Gradio versions
-def say_hello():
+def hello_world():
     return "Hello, World!"
 
-# Create the Gradio interface
 demo = gr.Interface(
-    fn=say_hello,
-    inputs=[],
-    outputs=gr.Textbox(label="Output"),
-    title="Hello World App"
+    fn=hello_world,
+    inputs=None,
+    outputs="text"
 )
 """
-    elif "calculator" in prompt.lower():
-        return """
+
+CALCULATOR_APP = """
 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
+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 "Please select an operation"
+        return "Invalid 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")
+        gr.Radio(["add", "subtract", "multiply", "divide"], label="Operation")
     ],
-    outputs=gr.Number(label="Result"),
-    title="Simple Calculator"
+    outputs="text"
 )
 """
-    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 """
+TEXT_ANALYZER_APP = """
 import gradio as gr
-import random
 
-# Simple sentiment analyzer (mock)
-def analyze_sentiment(text):
+def analyze_text(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"])
+    num_chars = len(text)
+    num_words = len(text.split())
     
-    return f"Length: {text_length} characters | Sentiment: {sentiment}"
+    return f"Characters: {num_chars}, Words: {num_words}"
 
-# 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"
+    fn=analyze_text,
+    inputs="text",
+    outputs="text"
 )
 """
 
 def call_openai_api(api_key, prompt):
-    """Direct API call to OpenAI"""
+    """Direct API call to OpenAI with minimal output requirements"""
     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. 
+    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.
 
-IMPORTANT: You MUST use gr.Interface() instead of gr.Blocks() for compatibility.
-DO NOT use Button.click() or any other component events.
+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
+
+Example of a valid app:
 
-Here's a template to follow:
 ```python
 import gradio as gr
 
-def my_function(input1, input2):
-    # Process inputs
-    result = input1 + input2  # Example operation
-    return result
+def my_function(text_input):
+    return f"You entered: {text_input}"
 
-# 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"
+    inputs="text",
+    outputs="text"
 )
 ```
 
 The code must:
-1. Import necessary libraries
-2. Define functions that handle the app logic
-3. Create a gr.Interface named 'demo'
+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
-5. Avoid using component events or callbacks
 """
     
     data = {
@@ -215,17 +120,20 @@ The code must:
         "max_tokens": 4000
     }
     
-    response = requests.post(
-        "https://api.openai.com/v1/chat/completions",
-        headers=headers,
-        json=data
-    )
-    
-    if response.status_code != 200:
-        return None, f"API Error: {response.status_code} - {response.text}"
-    
-    result = response.json()
-    return result["choices"][0]["message"]["content"], None
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=data
+        )
+        
+        if response.status_code != 200:
+            return None, f"API Error: {response.status_code} - {response.text}"
+        
+        result = response.json()
+        return result["choices"][0]["message"]["content"], None
+    except Exception as e:
+        return None, f"API Error: {str(e)}"
 
 def extract_code_blocks(text):
     """Extract code blocks from markdown"""
@@ -233,7 +141,7 @@ def extract_code_blocks(text):
     matches = re.findall(pattern, text)
     
     if not matches and text.strip():
-        if re.search(r'import\s+\w+|def\s+\w+\(|class\s+\w+:|if\s+__name__\s*==\s*[\'"]__main__[\'"]:', text):
+        if re.search(r'import\s+\w+|def\s+\w+\(|class\s+\w+:', text):
             return [text.strip()]
     
     return [match.strip() for match in matches]
@@ -268,109 +176,109 @@ def load_generated_app(code):
         except:
             pass
 
-# Create the main UI
-with gr.Blocks(title="AI Gradio App Generator") as demo:
-    gr.Markdown(f"# 🤖 AI Gradio App Generator (v{GRADIO_VERSION})")
+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
+
+# 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.")
     
-    with gr.Row():
-        with gr.Column():
-            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():
-                submit_btn = gr.Button("Generate App", variant="primary")
-                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("")
+    api_key = gr.Textbox(
+        label="OpenAI API Key", 
+        placeholder="sk-...",
+        type="password"
+    )
     
-    generated_app_container = gr.Group(visible=False)
+    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")
+    
+    app_container = gr.HTML(label="Generated App")
     
     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)
+        # 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>"
         
         try:
-            # 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)
+            # 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>"
             
-            # Extract code blocks
+            # Extract code from response
             code_blocks = extract_code_blocks(response)
             if not code_blocks:
-                return None, "⚠️ No valid code found in the response", gr.update(visible=False)
+                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>"
             
             code = code_blocks[0]
             
-            # 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 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()
+            # 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>"
             
-            # 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)
-    
-    def on_skip_api():
-        """Generate an app without using the API"""
-        app_code = generate_compatible_code(prompt.value)
+            return code, "App generated successfully!", f"<iframe src='/generated' width='100%' height='500px'></iframe>"
         
-        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)
+            # 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>"
+    
+    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>"
     
     submit_btn.click(
         on_submit,
         inputs=[api_key, prompt],
-        outputs=[code_output, status_output, generated_app_container]
+        outputs=[code_output, status_output, app_container]
     )
     
-    skip_api_btn.click(
-        on_skip_api,
-        inputs=[],
-        outputs=[code_output, status_output, generated_app_container]
+    template_btn.click(
+        on_template,
+        inputs=[prompt],
+        outputs=[code_output, status_output, app_container]
     )
 
+# 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)