Update app.py

app.py

@@ -1,316 +1,119 @@
 import gradio as gr
-import os
+import sys
 import tempfile
-import requests
 import subprocess
-import re
+import requests
 import time
-import sys
-
-# Global variables to track resources
-app_process = None
-temp_file_path = None
-
-def cleanup():
-    """Clean up resources when the app exits"""
-    global app_process, temp_file_path
-    
-    if app_process and app_process.poll() is None:
-        print("Stopping running process...")
-        app_process.terminate()
-        time.sleep(1)
-        if app_process.poll() is None:
-            app_process.kill()
-    
-    if temp_file_path and os.path.exists(temp_file_path):
-        print(f"Removing temp file: {temp_file_path}")
-        try:
-            os.unlink(temp_file_path)
-        except Exception as e:
-            print(f"Error removing temp file: {e}")
-
-# Register cleanup function to run at exit
+import os
+import re
 import atexit
-atexit.register(cleanup)
-
-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 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."""
-    
-    try:
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {api_key}"
-            },
-            json={
-                "model": "gpt-4o",
-                "messages": [
-                    {"role": "system", "content": "You are a Gradio expert. Provide only Python code without explanations."},
-                    {"role": "user", "content": prompt}
-                ],
-                "temperature": 0.2
-            }
-        )
-        
-        if response.status_code != 200:
-            return None, f"API Error: {response.status_code}"
-        
-        content = response.json()["choices"][0]["message"]["content"]
-        
-        # Extract code blocks if present
-        code_pattern = r'```python\s*([\s\S]*?)```'
-        code_matches = re.findall(code_pattern, content)
-        
-        if code_matches:
-            return code_matches[0], None
-        
-        # If no code blocks found, use the whole content
-        return content, None
-    
-    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
-    
-    # Stop any existing process
-    if app_process and app_process.poll() is None:
-        app_process.terminate()
-        time.sleep(1)
-        if app_process.poll() is None:
-            app_process.kill()
-    
-    # Remove any existing temp file
-    if temp_file_path and os.path.exists(temp_file_path):
-        try:
-            os.unlink(temp_file_path)
-        except:
-            pass
-    
-    # Create a new temp file
-    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(modified_code)
-    
-    # Run the app as a subprocess
-    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)
-"""
-    
-    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
-)
+# Print Python version and gradio version for debugging
+print(f"Python version: {sys.version}")
+print(f"Gradio version: {gr.__version__}")
 
-demo.launch(server_name="0.0.0.0", server_port=7861)
-"""
-    
-    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
+# Create a direct interface that doesn't use any subprocess 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 Simple Gradio App Generator")
-    
-    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")
+    gr.Markdown("# 🤖 Simple Gradio App Demo")
+    gr.Markdown("Select a simple demo app to try:")
     
-    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")
+    app_type = gr.Radio(
+        ["Hello World", "Calculator", "Text Analysis"],
+        label="Choose an App Type",
+        value="Hello World"
+    )
     
     with gr.Row():
-        stop_btn = gr.Button("Stop Running App", visible=False)
-    
-    code_display = gr.Code(label="Generated Code", language="python")
-    status = gr.Markdown("")
-    
-    # Frame to display the running app
-    app_display = gr.HTML("<div style='text-align:center; margin-top:20px;'>App will appear here</div>")
-    
-    def generate_and_run(key, desc):
-        if not key or len(key) < 20:
-            return None, "Please enter a valid API key", gr.update(visible=False), gr.update(visible=False)
-        
-        # Get code from API
-        code, error = get_app_code(key, desc)
-        if error:
-            return None, f"Error: {error}", gr.update(visible=False), gr.update(visible=False)
-        
-        # Run the app
-        success, run_error = run_gradio_app(code)
-        if not success:
-            return code, f"Error running app: {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, "✅ 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)
+        name_input = gr.Textbox(label="Your Name", value="World")
+        greeting_output = gr.Textbox(label="Result")
+    
+    with gr.Row(visible=False) as calculator_row:
+        num1 = gr.Number(label="First Number", value=5)
+        num2 = gr.Number(label="Second Number", value=3)
+        operation = gr.Radio(["Add", "Subtract", "Multiply", "Divide"], label="Operation", value="Add")
+        calc_result = gr.Textbox(label="Result")
+    
+    with gr.Row(visible=False) as text_row:
+        text_input = gr.Textbox(label="Enter some text", lines=3)
+        text_result = gr.Textbox(label="Analysis")
+    
+    # Hello World function
+    def greet(name):
+        return f"Hello, {name}!"
+    
+    # Calculator function
+    def calculate(num1, num2, op):
+        if op == "Add":
+            return str(num1 + num2)
+        elif op == "Subtract":
+            return str(num1 - num2)
+        elif op == "Multiply":
+            return str(num1 * num2)
+        elif op == "Divide":
+            if num2 == 0:
+                return "Error: Division by zero"
+            return str(num1 / num2)
+    
+    # Text Analysis function
+    def analyze_text(text):
+        if not text:
+            return "Please enter some text"
+        
+        num_chars = len(text)
+        num_words = len(text.split())
+        num_lines = len(text.splitlines())
+        
+        return f"Characters: {num_chars}\nWords: {num_words}\nLines: {num_lines}"
+    
+    # Switch UI based on selection
+    def update_ui(choice):
+        if choice == "Hello World":
+            return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+        elif choice == "Calculator":
+            return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+        else:  # Text Analysis
+            return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+    
+    app_type.change(
+        update_ui,
+        inputs=[app_type],
+        outputs=[
+            gr.Row.update(visible=True), 
+            calculator_row,
+            text_row
+        ]
+    )
     
-    def stop_app():
-        global app_process
-        
-        if app_process and app_process.poll() is None:
-            app_process.terminate()
-            time.sleep(1)
-            if app_process.poll() is None:
-                app_process.kill()
-        
-        return "App stopped", "<div style='text-align:center; margin-top:20px;'>App stopped</div>", gr.update(visible=False)
+    # Connect buttons to functions
+    name_input.submit(greet, inputs=[name_input], outputs=[greeting_output])
     
-    generate_btn.click(
-        generate_and_run,
-        inputs=[api_key, description],
-        outputs=[code_display, status, app_display, stop_btn]
+    # Calculator connections
+    calc_button = gr.Button("Calculate")
+    calc_button.click(
+        calculate, 
+        inputs=[num1, num2, operation], 
+        outputs=[calc_result]
     )
     
-    demo_btn.click(
-        run_demo,
-        inputs=[demo_type],
-        outputs=[code_display, status, app_display, stop_btn]
+    # Text analysis connection
+    analyze_button = gr.Button("Analyze Text")
+    analyze_button.click(
+        analyze_text,
+        inputs=[text_input],
+        outputs=[text_result]
     )
+
+    gr.Markdown("""
+    ### About This Demo
     
-    stop_btn.click(
-        stop_app,
-        inputs=[],
-        outputs=[status, app_display, stop_btn]
-    )
+    This is a simple demonstration of Gradio functionality with:
+    
+    1. A Hello World text generator
+    2. A basic calculator 
+    3. A text analysis tool
+    
+    Select different app types above to try them out.
+    """)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)