Update app.py

app.py

@@ -1,44 +1,16 @@
-import gradio as gr
+from flask import Flask, render_template, request, send_file, redirect, url_for
 from PIL import Image, ImageDraw
 import tempfile
 import os
 import requests
-import json
+import base64
+from io import BytesIO
 
-# Use Mistral-7B-Instruct model from Hugging Face
-def generate_mistral_response(prompt):
-    """
-    Uses the Mistral-7B-Instruct-v0.1 model to generate a response.
-    This model should be accessible without a subscription on Hugging Face.
-    """
-    API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.1"
-    
-    # Format the prompt according to Mistral's expected format
-    formatted_prompt = f"""<s>[INST] {prompt} [/INST]"""
-    
-    payload = {
-        "inputs": formatted_prompt,
-        "parameters": {
-            "max_new_tokens": 500,
-            "temperature": 0.7,
-            "top_p": 0.95,
-            "do_sample": True
-        }
-    }
-    
-    # Make the API call
-    try:
-        response = requests.post(API_URL, json=payload)
-        if response.status_code == 200:
-            return response.json()[0]["generated_text"].split("[/INST]")[1].strip()
-        else:
-            return f"Error: {response.status_code}, {response.text}"
-    except Exception as e:
-        return f"Error connecting to Mistral API: {str(e)}"
+app = Flask(__name__)
 
 def generate_passover_coloring_page(age):
     """
-    Generates a Passover-themed coloring page based on age using Mistral model.
+    Generates a Passover-themed coloring page based on age.
     """
     try:
         age = int(float(age))
@@ -47,64 +19,23 @@ def generate_passover_coloring_page(age):
     except (ValueError, TypeError):
         return "Please enter a valid number for age.", None
     
-    # Get coloring page ideas from Mistral
-    prompt = f"""I need to create a Passover-themed coloring page for a {age}-year-old child.
-    
-Based on this age, provide:
-1. A suitable Passover theme for the coloring page
-2. A brief description (1-2 sentences) of what elements should be included
-3. The appropriate complexity level (simple, basic, intermediate, or advanced)
-
-Keep your response concise and structured. Here's an example format:
-Theme: [theme name]
-Description: [brief description]
-Complexity: [complexity level]"""
-
-    try:
-        # Get response from Mistral
-        model_response = generate_mistral_response(prompt)
-        
-        # Parse the response to extract information
-        theme = "Passover"
-        description = "Passover symbols and elements"
+    # Define complexity based on age
+    if 1 <= age <= 3:
         complexity = "simple"
-        
-        # Try to extract the theme, description, and complexity from the response
-        if "Theme:" in model_response:
-            theme = model_response.split("Theme:")[1].split("\n")[0].strip()
-        if "Description:" in model_response:
-            description = model_response.split("Description:")[1].split("\n")[0].strip()
-        if "Complexity:" in model_response:
-            complexity = model_response.split("Complexity:")[1].split("\n")[0].strip().lower()
-            
-        # Ensure complexity is valid
-        if complexity not in ["simple", "basic", "intermediate", "advanced"]:
-            if age <= 3:
-                complexity = "simple"
-            elif age <= 6:
-                complexity = "basic"
-            elif age <= 9:
-                complexity = "intermediate"
-            else:
-                complexity = "advanced"
-    except Exception as e:
-        # Fallback if parsing fails
-        if age <= 3:
-            theme = "Matzah"
-            description = "Simple outline of matzah bread for coloring"
-            complexity = "simple"
-        elif age <= 6:
-            theme = "Seder Plate"
-            description = "Basic outline of a Seder plate with clear sections"
-            complexity = "basic"
-        elif age <= 9:
-            theme = "Exodus Story"
-            description = "Intermediate level scene from the Exodus story"
-            complexity = "intermediate"
-        else:
-            theme = "Passover Symbols"
-            description = "Advanced design with various Passover symbols"
-            complexity = "advanced"
+        theme = "Matzah"
+        description = "Simple outline of matzah bread for coloring"
+    elif 4 <= age <= 6:
+        complexity = "basic"
+        theme = "Seder Plate"
+        description = "Basic outline of a Seder plate with clear sections"
+    elif 7 <= age <= 9:
+        complexity = "intermediate"
+        theme = "Exodus Story"
+        description = "Intermediate level scene from the Exodus story"
+    else:
+        complexity = "advanced"
+        theme = "Passover Symbols"
+        description = "Advanced design with various Passover symbols"
     
     # Create a coloring page based on the theme and complexity
     img = Image.new('RGB', (600, 500), color='white')
@@ -120,14 +51,14 @@ Complexity: [complexity level]"""
     d.text((50, 130), f"{description}", fill='black')
     
     # Draw content based on the theme
-    if "Matzah" in theme:
+    if theme == "Matzah":
         # Matzah pattern
         d.rectangle([(150, 180), (450, 380)], outline='black', width=2)
         for i in range(160, 440, 25):
             for j in range(190, 370, 25):
                 d.ellipse([(i, j), (i+5, j+5)], fill='black')
                 
-    elif "Seder" in theme or "Plate" in theme:
+    elif theme == "Seder Plate":
         # Seder plate
         d.ellipse([(150, 180), (450, 380)], outline='black', width=2)
         # Divide into sections
@@ -135,30 +66,15 @@ Complexity: [complexity level]"""
         d.line([(150, 280), (450, 280)], fill='black', width=2)
         d.ellipse([(275, 255), (325, 305)], outline='black', width=2)
         
-    elif "Moses" in theme or "Exodus" in theme:
+    elif theme == "Exodus Story":
         # Simple boat/basket shape for baby Moses
         d.arc([(150, 250), (450, 400)], 0, 180, fill='black', width=2)
         d.line([(150, 325), (450, 325)], fill='black', width=2)
         # Water waves
         for i in range(170, 430, 50):
             d.arc([(i, 350), (i+30, 370)], 0, 180, fill='black', width=2)
-            
-    elif "Plague" in theme or "Frog" in theme:
-        # Frog outline (representing the plagues)
-        # Body
-        d.ellipse([(250, 230), (350, 300)], outline='black', width=2)
-        # Head
-        d.ellipse([(275, 180), (325, 230)], outline='black', width=2)
-        # Eyes
-        d.ellipse([(280, 190), (290, 200)], outline='black', width=2)
-        d.ellipse([(310, 190), (320, 200)], outline='black', width=2)
-        # Legs
-        d.line([(250, 265), (200, 290)], fill='black', width=2)
-        d.line([(350, 265), (400, 290)], fill='black', width=2)
-        d.line([(270, 300), (240, 350)], fill='black', width=2)
-        d.line([(330, 300), (360, 350)], fill='black', width=2)
         
-    elif "Symbol" in theme or "Hebrew" in theme:
+    else:  # Passover Symbols
         # Draw Star of David
         center_x, center_y = 300, 280
         radius = 80
@@ -181,101 +97,143 @@ Complexity: [complexity level]"""
         
         d.line(points1, fill='black', width=2)
         d.line(points2, fill='black', width=2)
-        
-    else:
-        # Default: Simple Passover scene with pyramids and figures
-        # Pyramids
-        d.polygon([(150, 380), (250, 200), (350, 380)], outline='black', width=2)
-        d.polygon([(300, 380), (400, 220), (500, 380)], outline='black', width=2)
-        
-        # Figures (simple stick figures)
-        for i in range(180, 500, 80):
-            # Body
-            d.line([(i, 350), (i, 320)], fill='black', width=2)
-            # Head
-            d.ellipse([(i-5, 310), (i+5, 320)], outline='black', width=2)
-            # Arms
-            d.line([(i-10, 335), (i+10, 335)], fill='black', width=2)
-            # Legs
-            d.line([(i, 350), (i-7, 370)], fill='black', width=2)
-            d.line([(i, 350), (i+7, 370)], fill='black', width=2)
     
-    # Save to a temporary file
-    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
-        temp_path = temp_file.name
-        img.save(temp_path)
+    # Convert image to base64 for HTML display
+    buffered = BytesIO()
+    img.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    
+    # Create the response text
+    response = {
+        "age": age,
+        "theme": theme,
+        "description": description,
+        "complexity": complexity,
+        "image": img_str
+    }
     
-    # Create the response text with the model's insights
-    response = f"## Passover Coloring Page for a {age}-year-old\n\n"
-    response += f"**Theme**: {theme}\n\n"
-    response += f"**Description**: {description}\n\n"
-    response += f"**Complexity**: {complexity.capitalize()}\n\n"
+    return response
+
+# Home page
+@app.route('/', methods=['GET', 'POST'])
+def home():
+    result = None
     
-    # Add Mistral's full response as additional context
-    response += "---\n\n"
-    response += "### Mistral AI's Suggestion:\n\n"
-    response += f"{model_response}"
+    if request.method == 'POST':
+        try:
+            age = request.form.get('age')
+            if age:
+                result = generate_passover_coloring_page(age)
+        except Exception as e:
+            return render_template('index.html', error=str(e))
     
-    return response, temp_path
+    return render_template('index.html', result=result)
 
-# Create a simple UI that avoids the API issue
-with gr.Blocks() as demo:
-    gr.Markdown("# Passover Coloring Pages Generator")
-    gr.Markdown("### Powered by Mistral-7B-Instruct")
-    
-    with gr.Row():
-        with gr.Column():
-            age_input = gr.Slider(
-                minimum=1, 
-                maximum=12, 
-                step=1, 
-                value=6,
-                label="Child's Age"
-            )
-            generate_btn = gr.Button("Generate Coloring Page")
+# Create temporary templates directory and files if they don't exist
+def create_templates():
+    templates_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')
+    if not os.path.exists(templates_dir):
+        os.makedirs(templates_dir)
+    
+    # Create index.html template
+    index_html = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Passover Coloring Pages Generator</title>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                max-width: 800px;
+                margin: 0 auto;
+                padding: 20px;
+            }
+            h1 {
+                color: #2c3e50;
+            }
+            .form-container {
+                margin: 20px 0;
+                padding: 15px;
+                border: 1px solid #ddd;
+                border-radius: 5px;
+            }
+            label {
+                display: block;
+                margin-bottom: 5px;
+                font-weight: bold;
+            }
+            input, button {
+                padding: 8px;
+                margin-bottom: 15px;
+            }
+            button {
+                background-color: #3498db;
+                color: white;
+                border: none;
+                cursor: pointer;
+                border-radius: 4px;
+            }
+            button:hover {
+                background-color: #2980b9;
+            }
+            .result-container {
+                margin-top: 20px;
+                padding: 15px;
+                border: 1px solid #ddd;
+                border-radius: 5px;
+            }
+            .image-container {
+                margin-top: 20px;
+                text-align: center;
+            }
+            .image-container img {
+                max-width: 100%;
+                border: 1px solid #ddd;
+            }
+            .error {
+                color: red;
+                font-weight: bold;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Passover Coloring Pages Generator</h1>
         
-    with gr.Row():
-        with gr.Column():
-            output_text = gr.Markdown()
+        <div class="form-container">
+            <form method="POST">
+                <label for="age">Child's Age (1-12):</label>
+                <input type="number" id="age" name="age" min="1" max="12" value="6" required>
+                <button type="submit">Generate Coloring Page</button>
+            </form>
+        </div>
         
-    with gr.Row():
-        output_image = gr.Image(label="Coloring Page")
-    
-    generate_btn.click(
-        generate_passover_coloring_page, 
-        inputs=age_input, 
-        outputs=[output_text, output_image]
-    )
-
-# Launch with the patched method to avoid API issues
-if __name__ == "__main__":
-    # Override the app.get_blocks().get_api_info() method that's causing the error
-    original_launch = demo.launch
-    
-    def patched_launch(*args, **kwargs):
-        # Skip the problematic API processing in routes.py
-        try:
-            import types
-            from gradio import routes
-            
-            # Create a dummy method that returns an empty dict to avoid the error
-            def dummy_api_info(self):
-                return {"endpoints": {}, "components": [], "dependencies": []}
+        {% if error %}
+        <div class="error">
+            {{ error }}
+        </div>
+        {% endif %}
+        
+        {% if result %}
+        <div class="result-container">
+            <h2>Passover Coloring Page for a {{ result.age }}-year-old</h2>
+            <p><strong>Theme:</strong> {{ result.theme }}</p>
+            <p><strong>Description:</strong> {{ result.description }}</p>
+            <p><strong>Complexity:</strong> {{ result.complexity|capitalize }}</p>
             
-            # Try to patch FastAPI.api_info
-            try:
-                if hasattr(routes, 'FastAPI'):
-                    original_api_info = routes.FastAPI.api_info
-                    routes.FastAPI.api_info = types.MethodType(dummy_api_info, routes.FastAPI)
-            except:
-                pass
-                
-        except:
-            pass
+            <div class="image-container">
+                <img src="data:image/png;base64,{{ result.image }}" alt="Passover Coloring Page">
+            </div>
             
-        # Call the original launch method
-        return original_launch(*args, **kwargs)
+            <p><em>Print this page for coloring!</em></p>
+        </div>
+        {% endif %}
+    </body>
+    </html>
+    """
     
-    # Replace the launch method with our patched version
-    demo.launch = patched_launch
-    demo.launch(share=False)
+    with open(os.path.join(templates_dir, 'index.html'), 'w') as f:
+        f.write(index_html)
+
+if __name__ == '__main__':
+    create_templates()
+    app.run(debug=True, host='0.0.0.0', port=8080)