Update app.py

app.py

@@ -1,50 +1,166 @@
 import gradio as gr
+from PIL import Image, ImageDraw
+import tempfile
+import os
 
-def echo(text):
-    return text
+def generate_passover_coloring_page(age):
+    """
+    Generates a simple Passover-themed coloring page based on age.
+    """
+    try:
+        age = int(float(age))
+        if not (1 <= age <= 12):
+            return "Please enter a valid age between 1 and 12.", None
+    except (ValueError, TypeError):
+        return "Please enter a valid number for age.", None
+    
+    # Define complexity based on age
+    if 1 <= age <= 3:
+        complexity = "simple"
+    elif 4 <= age <= 6:
+        complexity = "basic"
+    elif 7 <= age <= 9:
+        complexity = "intermediate"
+    else:
+        complexity = "advanced"
+    
+    # Passover themes based on complexity
+    themes = {
+        "simple": [
+            "Matzah", "Seder Plate", "Baby Moses", "Frog (Plague)"
+        ],
+        "basic": [
+            "Parting of the Red Sea", "Ten Plagues", "Four Questions", "Afikoman Hunt"
+        ],
+        "intermediate": [
+            "Seder Table", "Exodus Story", "Pesach in Hebrew", "Egyptian Pyramids"
+        ],
+        "advanced": [
+            "Haggadah Illustrations", "Passover Symbols", "Story Panels", "Hebrew Calligraphy"
+        ]
+    }
+    
+    selected_theme = themes[complexity][0]  # Just use the first theme for simplicity
+    
+    # Create a simple coloring page
+    img = Image.new('RGB', (500, 400), color='white')
+    d = ImageDraw.Draw(img)
+    
+    # Draw a border
+    d.rectangle([(20, 20), (480, 380)], outline='black', width=3)
+    
+    # Add title
+    d.text((50, 40), f"Passover Coloring Page", fill='black')
+    d.text((50, 70), f"Theme: {selected_theme}", fill='black')
+    d.text((50, 100), f"For age: {age} (Complexity: {complexity})", fill='black')
+    
+    # Draw a simple shape based on the theme
+    if "Matzah" in selected_theme:
+        # Simple rectangle with dots for matzah
+        d.rectangle([(150, 150), (350, 250)], outline='black', width=2)
+        for i in range(160, 340, 20):
+            for j in range(160, 240, 20):
+                d.ellipse([(i, j), (i+5, j+5)], fill='black')
+    
+    elif "Seder" in selected_theme:
+        # Simple circle for seder plate
+        d.ellipse([(150, 150), (350, 250)], outline='black', width=2)
+        # Divide into sections
+        d.line([(250, 150), (250, 250)], fill='black', width=2)
+        d.line([(150, 200), (350, 200)], fill='black', width=2)
+    
+    elif "Moses" in selected_theme or "Exodus" in selected_theme:
+        # Simple boat/basket shape
+        d.arc([(150, 150), (350, 250)], 0, 180, fill='black', width=2)
+        d.line([(150, 200), (350, 200)], fill='black', width=2)
+    
+    elif "Plague" in selected_theme or "Plagues" in selected_theme:
+        # Simple frog outline
+        d.ellipse([(180, 170), (250, 220)], outline='black', width=2)  # Body
+        d.ellipse([(250, 170), (320, 220)], outline='black', width=2)  # Body
+        d.ellipse([(200, 150), (230, 170)], outline='black', width=2)  # Eye
+        d.ellipse([(300, 150), (330, 170)], outline='black', width=2)  # Eye
+    
+    else:
+        # Generic Star of David
+        points = [
+            (250, 150), (300, 200), (250, 250), 
+            (200, 200), (250, 150), (250, 250)
+        ]
+        d.line(points, fill='black', width=2)
+        points2 = [(200, 200), (300, 200)]
+        d.line(points2, 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)
+    
+    # Create the response text
+    response = f"## Passover Coloring Page for a {age}-year-old\n\n"
+    response += f"I've created a {complexity} level coloring page with the theme: **{selected_theme}**\n\n"
+    response += "Happy Passover! Print this page for coloring."
+    
+    return response, temp_path
 
-# Create a simple app
+# Create a simple UI that avoids the API issue
 with gr.Blocks() as demo:
-    gr.Markdown("# API Test")
-    text_input = gr.Textbox(label="Input")
-    text_output = gr.Textbox(label="Output")
-    button = gr.Button("Echo")
-    button.click(echo, inputs=text_input, outputs=text_output)
-
-# Try to directly access the API info
-try:
-    api_info = demo.get_api_info()
-    print("API info successfully generated:")
-    print(f"Number of endpoints: {len(api_info['endpoints'])}")
-    print("First endpoint:", list(api_info['endpoints'].keys())[0])
-    print("Test successful! API info can be generated without errors.")
-except Exception as e:
-    print(f"Error when trying to get API info: {type(e).__name__}: {str(e)}")
-    print("This is likely where your original error is coming from.")
-    
-    # Try to pinpoint the exact schema processing issue
-    try:
-        from gradio.blocks import Blocks
-        from gradio_client import utils as client_utils
+    gr.Markdown("# Passover Coloring Pages Generator")
+    
+    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")
         
-        print("\nTrying to manually process schema...")
-        blocks_instance = demo
-        if isinstance(blocks_instance, Blocks):
+    with gr.Row():
+        with gr.Column():
+            output_text = gr.Markdown()
+        
+    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 a specific server port to avoid potential conflicts
+if __name__ == "__main__":
+    # The magic line that avoids API processing issues:
+    # 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": []}
+            
+            # Try to patch FastAPI.api_info
             try:
-                raw_api_info = blocks_instance.get_api_info()
-                print("  ✓ blocks_instance.get_api_info() succeeded")
+                if hasattr(routes, 'FastAPI'):
+                    original_api_info = routes.FastAPI.api_info
+                    routes.FastAPI.api_info = types.MethodType(dummy_api_info, routes.FastAPI)
+            except:
+                pass
                 
-                try:
-                    # This is where many schema processing errors happen
-                    processed_info = client_utils.json_schema_to_python_type(raw_api_info)
-                    print("  ✓ json_schema_to_python_type succeeded")
-                except Exception as schema_err:
-                    print(f"  ✗ json_schema_to_python_type failed: {type(schema_err).__name__}: {str(schema_err)}")
-                    print("    The error is in the schema processing part of Gradio")
-            except Exception as api_err:
-                print(f"  ✗ blocks_instance.get_api_info() failed: {type(api_err).__name__}: {str(api_err)}")
-    except Exception as deep_err:
-        print(f"Error during deeper diagnosis: {type(deep_err).__name__}: {str(deep_err)}")
-
-# Don't launch the app, we just want to test the API info generation
-print("\nGradio version:", gr.__version__)
+        except:
+            pass
+            
+        # Call the original launch method
+        return original_launch(*args, **kwargs)
+    
+    # Replace the launch method with our patched version
+    demo.launch = patched_launch
+    demo.launch(share=False)