Update app.py

app.py

@@ -37,11 +37,15 @@ def get_app_code(api_key, description):
     """Get app code from the OpenAI API"""
     prompt = f"""Create a simple Gradio app that {description}.
     
+    VERY IMPORTANT: You MUST include this to disable flagging which creates permission errors:
+    gr.Interface(..., flagging_callback=None)
+    
     The app should:
-    1. Use ONLY gr.Interface (not Blocks)
+    1. Use gr.Interface with flagging_callback=None
     2. Be self-contained and not use any external dependencies
     3. Use only Python standard library and NumPy/Pandas if needed
     4. Include demo.launch(server_name="0.0.0.0", server_port=7861) at the end
+    5. Do NOT create any directories or write any files
     
     Provide ONLY Python code with no explanation or markdown."""
     
@@ -80,6 +84,15 @@ def get_app_code(api_key, description):
     except Exception as e:
         return None, f"Error: {str(e)}"
 
+def ensure_flagging_disabled(code):
+    """Ensure flagging is disabled in the code"""
+    # Check if flagging_callback=None is present in Interface creation
+    if 'Interface(' in code and 'flagging_callback=None' not in code:
+        # Insert flagging_callback=None in the Interface parameters
+        code = code.replace('Interface(', 'Interface(flagging_callback=None, ')
+    
+    return code
+
 def run_gradio_app(code):
     """Save the code to a temp file and run it as a subprocess"""
     global app_process, temp_file_path
@@ -102,31 +115,127 @@ def run_gradio_app(code):
     fd, temp_file_path = tempfile.mkstemp(suffix='.py')
     os.close(fd)
     
+    # Ensure flagging is disabled
+    modified_code = ensure_flagging_disabled(code)
+    
     # Write code to file
     with open(temp_file_path, 'w') as f:
-        f.write(code)
+        f.write(modified_code)
     
     # Run the app as a subprocess
-    app_process = subprocess.Popen([sys.executable, temp_file_path])
-    
-    # Wait a moment for the app to start
-    time.sleep(3)
+    try:
+        app_process = subprocess.Popen(
+            [sys.executable, temp_file_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        # Wait a moment for the app to start
+        time.sleep(3)
+        
+        # Check if process is still running
+        if app_process.poll() is not None:
+            # Get error output
+            _, stderr = app_process.communicate()
+            error_msg = stderr.decode('utf-8')
+            return False, f"App failed to start:\n{error_msg}"
+        
+        return True, None
+    except Exception as e:
+        return False, f"Error launching app: {str(e)}"
+
+# Create demo app for direct usage
+def make_demo_app(app_type):
+    """Create a simple demo app based on type"""
+    if app_type == "calculator":
+        return """
+import gradio as gr
+import numpy as np
+
+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":
+        return num1 / num2 if num2 != 0 else "Error: Division by zero"
+    else:
+        return "Invalid operation"
+
+demo = gr.Interface(
+    fn=calculate,
+    inputs=[
+        gr.Number(label="First Number"),
+        gr.Number(label="Second Number"),
+        gr.Radio(["Add", "Subtract", "Multiply", "Divide"], label="Operation")
+    ],
+    outputs=gr.Textbox(label="Result"),
+    title="Simple Calculator",
+    flagging_callback=None
+)
+
+demo.launch(server_name="0.0.0.0", server_port=7861)
+"""
     
-    # Check if process is still running
-    if app_process.poll() is not None:
-        return False, f"App failed to start (exit code: {app_process.returncode})"
+    elif app_type == "image":
+        return """
+import gradio as gr
+import numpy as np
+from PIL import Image
+
+def grayscale(img):
+    gray_img = np.mean(img, axis=2).astype(np.uint8)
+    return gray_img
+
+demo = gr.Interface(
+    fn=grayscale,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Image(type="numpy"),
+    title="Image Grayscale Converter",
+    flagging_callback=None
+)
+
+demo.launch(server_name="0.0.0.0", server_port=7861)
+"""
     
-    return True, None
+    else:  # Default hello world
+        return """
+import gradio as gr
+
+def greet(name):
+    return f"Hello, {name}!"
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=gr.Textbox(label="Your Name"),
+    outputs=gr.Textbox(label="Greeting"),
+    title="Hello World App",
+    flagging_callback=None
+)
+
+demo.launch(server_name="0.0.0.0", server_port=7861)
+"""
 
 # Create a very simple Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("# 🤖 Simple Gradio App Generator")
     
-    api_key = gr.Textbox(label="OpenAI API Key", placeholder="sk-...", type="password")
-    description = gr.Textbox(label="Describe the app you want", lines=3)
+    with gr.Tab("Generate Custom App"):
+        api_key = gr.Textbox(label="OpenAI API Key", placeholder="sk-...", type="password")
+        description = gr.Textbox(label="Describe the app you want", lines=3)
+        generate_btn = gr.Button("Generate & Run App")
+    
+    with gr.Tab("Quick Demo Apps"):
+        demo_type = gr.Radio(
+            ["hello", "calculator", "image"], 
+            label="Select Demo App", 
+            value="hello"
+        )
+        demo_btn = gr.Button("Run Demo App")
     
     with gr.Row():
-        generate_btn = gr.Button("Generate & Run App")
         stop_btn = gr.Button("Stop Running App", visible=False)
     
     code_display = gr.Code(label="Generated Code", language="python")
@@ -158,6 +267,22 @@ with gr.Blocks() as demo:
         
         return code, "✅ App is running! View it below:", iframe, gr.update(visible=True)
     
+    def run_demo(app_type):
+        code = make_demo_app(app_type)
+        success, run_error = run_gradio_app(code)
+        
+        if not success:
+            return code, f"Error running demo: {run_error}", gr.update(visible=False), gr.update(visible=False)
+        
+        # Create iframe to show the app
+        iframe = f"""
+        <div style="border:1px solid #ddd; border-radius:5px; height:500px; margin-top:10px;">
+            <iframe src="http://localhost:7861" width="100%" height="100%" frameborder="0"></iframe>
+        </div>
+        """
+        
+        return code, "✅ Demo app is running! View it below:", iframe, gr.update(visible=True)
+    
     def stop_app():
         global app_process
         
@@ -175,6 +300,12 @@ with gr.Blocks() as demo:
         outputs=[code_display, status, app_display, stop_btn]
     )
     
+    demo_btn.click(
+        run_demo,
+        inputs=[demo_type],
+        outputs=[code_display, status, app_display, stop_btn]
+    )
+    
     stop_btn.click(
         stop_app,
         inputs=[],