Update app.py

app.py

@@ -1,204 +1,38 @@
-import os
-import importlib.util
-import sys
-import tempfile
-import traceback
-from pathlib import Path
+FROM python:3.9-slim
 
-import gradio as gr
-import openai
-from flask import Flask, render_template, request, jsonify
-from dotenv import load_dotenv
+WORKDIR /app
 
-from utils import sanitize_code, extract_code_blocks, validate_gradio_code
+# Create a non-root user
+RUN useradd -m appuser
 
-# Load environment variables
-load_dotenv()
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
 
-# Configure OpenAI API
-openai.api_key = os.getenv("OPENAI_API_KEY")
-if not openai.api_key:
-    raise ValueError("OPENAI_API_KEY environment variable is not set")
+# Create directories for matplotlib and set appropriate permissions
+RUN mkdir -p /home/appuser/.config/matplotlib && \
+    chown -R appuser:appuser /home/appuser/.config
 
-app = Flask(__name__)
-generated_app = None
-current_code = ""
+# Copy requirements file
+COPY requirements.txt .
 
-def generate_gradio_app(prompt):
-    """Generate Gradio app code using OpenAI API"""
-    try:
-        response = openai.chat.completions.create(
-            model="gpt-4o",  # Using gpt-4o for best code generation
-            messages=[
-                {"role": "system", "content": """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.
-                The code must:
-                1. Import all necessary libraries
-                2. Define a complete, functional Gradio interface
-                3. Launch the interface with share=False and show_api=False
-                4. Use gr.Blocks() for complex interfaces
-                5. Handle errors gracefully
-                6. Use relative paths for any file operations
-                7. NOT use external APIs or services unless specifically requested
-                8. Be completely self-contained in a single script
-                9. End with a simple if __name__ == "__main__": block that launches the app
-                """
-                },
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.2,
-            max_tokens=4000
-        )
-        
-        generated_code = response.choices[0].message.content
-        code_blocks = extract_code_blocks(generated_code)
-        
-        if code_blocks:
-            return code_blocks[0], None
-        else:
-            return generated_code, None
-            
-    except Exception as e:
-        return None, str(e)
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-def load_and_run_gradio_app(code):
-    """Load and run the generated Gradio app code"""
-    global generated_app, current_code
-    
-    # Check if code is safe to execute
-    is_valid, error_msg = validate_gradio_code(code)
-    if not is_valid:
-        return None, error_msg
-    
-    # Clean up previous app if it exists
-    if generated_app:
-        try:
-            generated_app.close()
-        except:
-            pass
-    
-    # Save code to a temporary file
-    with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
-        f.write(code.encode('utf-8'))
-        temp_file = f.name
-    
-    try:
-        # Import the module
-        module_name = os.path.basename(temp_file).replace('.py', '')
-        spec = importlib.util.spec_from_file_location(module_name, temp_file)
-        module = importlib.util.module_from_spec(spec)
-        sys.modules[module_name] = module
-        spec.loader.exec_module(module)
-        
-        # Find the Gradio interface
-        for attr_name in dir(module):
-            attr = getattr(module, attr_name)
-            if isinstance(attr, gr.Blocks) or isinstance(attr, gr.Interface):
-                # Save a reference to the app
-                generated_app = attr
-                current_code = code
-                
-                # Return the app
-                return attr, None
-        
-        return None, "No Gradio interface found in the generated code"
-        
-    except Exception as e:
-        error_details = traceback.format_exc()
-        return None, f"Error executing the generated code: {str(e)}\n{error_details}"
-    finally:
-        # Clean up the temporary file
-        try:
-            os.unlink(temp_file)
-        except:
-            pass
+# Copy application files
+COPY app.py .
+COPY utils.py .
 
-def create_ui():
-    """Create the main Gradio interface"""
-    with gr.Blocks(title="Dynamic Gradio App Generator") as interface:
-        gr.Markdown("# 🤖 Dynamic Gradio App Generator")
-        gr.Markdown("Describe the Gradio app you want to create, and the AI will generate and run it for you.")
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                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 & Run App", variant="primary")
-                    clear_btn = gr.Button("Clear", variant="secondary")
-                
-                with gr.Accordion("Generated Code", open=False):
-                    code_output = gr.Code(language="python", label="Generated Code")
-            
-            with gr.Column(scale=3):
-                output = gr.Markdown("Your generated app will appear here.")
-                error_output = gr.Markdown(visible=False)
-        
-        def on_submit(prompt_text):
-            # Generate the Gradio app code
-            code, error = generate_gradio_app(prompt_text)
-            if error:
-                return None, f"⚠️ **Error generating code**: {error}", gr.update(visible=True), None
-            
-            # Load and run the generated app
-            app, run_error = load_and_run_gradio_app(code)
-            if run_error:
-                return code, f"⚠️ **Error running the generated app**: {run_error}", gr.update(visible=True), None
-            
-            # Create an iframe to display the app
-            iframe_html = f'<iframe src="/generated_app" width="100%" height="800px" frameborder="0"></iframe>'
-            return code, "", gr.update(visible=False), iframe_html
-        
-        def on_clear():
-            return "", "", gr.update(visible=False), "Your generated app will appear here."
-        
-        submit_btn.click(
-            on_submit, 
-            inputs=[prompt], 
-            outputs=[code_output, error_output, error_output, output]
-        )
-        
-        clear_btn.click(
-            on_clear,
-            inputs=[],
-            outputs=[prompt, code_output, error_output, output]
-        )
-    
-    return interface
+# Set environment variable for matplotlib
+ENV MPLCONFIGDIR=/home/appuser/.config/matplotlib
 
-# Flask routes to handle the generated app
-@app.route('/generated_app')
-def serve_generated_app():
-    """Serve the generated Gradio app"""
-    if not generated_app:
-        return "No app has been generated yet. Please create one first."
-    
-    # Create a tempfile with the current code
-    with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
-        f.write(current_code.encode('utf-8'))
-        temp_file = f.name
-    
-    # Execute the code in a subprocess
-    # This is a simplified version - in a real app, you'd need a more robust solution
-    import subprocess
-    result = subprocess.run([sys.executable, temp_file], capture_output=True, text=True)
-    
-    # Clean up
-    os.unlink(temp_file)
-    
-    if result.returncode != 0:
-        return f"Error running the app: {result.stderr}"
-    
-    return result.stdout
+# Expose port for the application
+EXPOSE 7860
 
-if __name__ == "__main__":
-    # Create the Gradio interface
-    demo = create_ui()
-    
-    # Launch the Gradio app
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+# Switch to the non-root user
+USER appuser
+
+# Command to run the application
+CMD ["python", "app.py"]