Update app.py

app.py

@@ -1,16 +1,16 @@
-# app.py - Hugging Face Compatible Version
 import streamlit as st
-import requests
-import json
+import os
 import time
 import base64
 import random
+import tempfile
+import subprocess
+import numpy as np
+import pygame
+import matplotlib.pyplot as plt
 from PIL import Image
 import io
-import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-from matplotlib.animation import FuncAnimation
-import numpy as np
+from manim import *
 
 # Configure Streamlit page
 st.set_page_config(
@@ -113,6 +113,23 @@ st.markdown("""
             flex-wrap: wrap;
         }
     }
+    
+    .animation-container {
+        background-color: #1a1a2e;
+        border-radius: 15px;
+        padding: 20px;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+        margin-bottom: 25px;
+        position: relative;
+        overflow: hidden;
+    }
+    
+    .animation-canvas {
+        border-radius: 10px;
+        overflow: hidden;
+        margin: 0 auto;
+        display: block;
+    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -155,15 +172,270 @@ CONCEPTS = {
     }
 }
 
-# Free AI models via Hugging Face Inference API
-HF_API_URL = "https://api-inference.huggingface.co/models/"
-MODELS = {
-    "codegen": "Salesforce/codegen-350M-mono",
-    "story": "gpt2"
+# Character database
+CHARACTERS = {
+    "rabbit": {"color": (255, 150, 150), "speed": 5, "size": 30},
+    "dragon": {"color": (255, 100, 100), "speed": 3, "size": 60},
+    "cat": {"color": (200, 150, 255), "speed": 6, "size": 25},
+    "dog": {"color": (255, 200, 150), "speed": 7, "size": 35},
+    "knight": {"color": (150, 200, 255), "speed": 4, "size": 40},
+    "wizard": {"color": (200, 255, 150), "speed": 4, "size": 35},
+    "scientist": {"color": (150, 255, 200), "speed": 5, "size": 30},
+    "pirate": {"color": (255, 255, 150), "speed": 5, "size": 40}
+}
+
+# Animation templates
+ANIMATION_TEMPLATES = {
+    "loop": {
+        "pygame": """
+import pygame
+import sys
+import math
+
+# Initialize pygame
+pygame.init()
+
+# Screen setup
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Your Story Animation")
+
+# Colors
+BACKGROUND = (25, 25, 50)
+GROUND = (40, 100, 40)
+SUN = (255, 255, 200)
+
+# Character setup
+character = "{character}"
+char_color = {char_color}
+char_size = {char_size}
+char_x = 100
+char_y = HEIGHT - 100
+char_speed = {char_speed}
+
+# Target setup
+target_x = 700
+target_y = HEIGHT - 100
+target_reached = False
+hops = 0
+
+# Animation clock
+clock = pygame.time.Clock()
+frames = []
+
+# Main animation loop
+for frame in range(120):
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            pygame.quit()
+            sys.exit()
+    
+    # Clear screen
+    screen.fill(BACKGROUND)
+    
+    # Draw ground
+    pygame.draw.rect(screen, GROUND, (0, HEIGHT - 50, WIDTH, 50))
+    
+    # Draw sun
+    pygame.draw.circle(screen, SUN, (700, 100), 50)
+    
+    # Draw target
+    pygame.draw.circle(screen, (255, 200, 100), (target_x, target_y), 30)
+    pygame.draw.circle(screen, (255, 150, 50), (target_x, target_y), 20)
+    pygame.draw.circle(screen, (255, 100, 0), (target_x, target_y), 10)
+    
+    # Move character
+    if not target_reached:
+        char_x += char_speed
+        # Hop animation
+        hop_height = 50 * math.sin(frame * 0.2)
+        char_y = HEIGHT - 100 - abs(hop_height)
+        
+        # Check if target reached
+        if char_x >= target_x - 40:
+            hops += 1
+            char_x = 100
+            if hops >= {count}:
+                target_reached = True
+    
+    # Draw character
+    pygame.draw.circle(screen, char_color, (int(char_x), int(char_y)), char_size)
+    
+    # Draw eyes
+    pygame.draw.circle(screen, (255, 255, 255), (int(char_x + 10), int(char_y - 5)), 8)
+    pygame.draw.circle(screen, (0, 0, 0), (int(char_x + 10), int(char_y - 5)), 4)
+    
+    # Draw hop counter
+    font = pygame.font.SysFont(None, 36)
+    text = font.render(f"Hops: {{hops}}/{{count}}", True, (255, 255, 255))
+    screen.blit(text, (20, 20))
+    
+    # Capture frame
+    frames.append(pygame.surfarray.array3d(screen).swapaxes(0, 1))
+    
+    pygame.display.flip()
+    clock.tick(30)
+
+# Save animation as GIF
+import imageio
+imageio.mimsave('animation.gif', frames, fps=30)
+        """
+    },
+    "conditional": {
+        "pygame": """
+import pygame
+import sys
+
+# Initialize pygame
+pygame.init()
+
+# Screen setup
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Your Story Animation")
+
+# Colors
+BACKGROUND = (25, 25, 50)
+GROUND = (40, 100, 40)
+CHEST_COLOR = (139, 69, 19)
+LOCK_COLOR = (192, 192, 192)
+TREASURE_COLOR = (255, 215, 0)
+
+# Knight setup
+knight_x = 100
+knight_y = HEIGHT - 100
+knight_speed = 4
+knight_size = 40
+knight_color = (100, 150, 255)
+
+# Chest setup
+chest_x = 600
+chest_y = HEIGHT - 100
+chest_width = 80
+chest_height = 50
+is_unlocked = {condition}
+
+# Animation clock
+clock = pygame.time.Clock()
+frames = []
+
+# Main animation loop
+for frame in range(180):
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            pygame.quit()
+            sys.exit()
+    
+    # Clear screen
+    screen.fill(BACKGROUND)
+    
+    # Draw ground
+    pygame.draw.rect(screen, GROUND, (0, HEIGHT - 50, WIDTH, 50))
+    
+    # Draw chest
+    pygame.draw.rect(screen, CHEST_COLOR, (chest_x, chest_y, chest_width, chest_height))
+    pygame.draw.rect(screen, (101, 67, 33), (chest_x, chest_y, chest_width, 20))
+    
+    # Draw lock or treasure
+    if not is_unlocked:
+        pygame.draw.rect(screen, LOCK_COLOR, (chest_x + chest_width//2 - 10, chest_y - 15, 20, 15))
+        pygame.draw.circle(screen, LOCK_COLOR, (chest_x + chest_width//2, chest_y - 15), 8)
+    else:
+        pygame.draw.rect(screen, (255, 223, 0), (chest_x + 10, chest_y + 10, 20, 30))
+        pygame.draw.rect(screen, (218, 165, 32), (chest_x + 50, chest_y + 15, 20, 20))
+    
+    # Move knight
+    if knight_x < chest_x - 100:
+        knight_x += knight_speed
+    
+    # Draw knight
+    pygame.draw.circle(screen, knight_color, (knight_x, knight_y), knight_size)
+    pygame.draw.rect(screen, (50, 50, 150), (knight_x - 15, knight_y - 50, 30, 50))  # Body
+    pygame.draw.circle(screen, (200, 200, 200), (knight_x, knight_y - 60), 15)  # Head
+    
+    # Draw text
+    font = pygame.font.SysFont(None, 36)
+    if is_unlocked:
+        text = font.render("Chest is unlocked! Treasure acquired!", True, (255, 255, 100))
+    else:
+        text = font.render("Chest is locked! Find the key!", True, (255, 100, 100))
+    screen.blit(text, (WIDTH//2 - text.get_width()//2, 50))
+    
+    # Capture frame
+    frames.append(pygame.surfarray.array3d(screen).swapaxes(0, 1))
+    
+    pygame.display.flip()
+    clock.tick(30)
+
+# Save animation as GIF
+import imageio
+imageio.mimsave('animation.gif', frames, fps=30)
+        """
+    },
+    "function": {
+        "manim": """
+from manim import *
+
+class FunctionMagic(Scene):
+    def construct(self):
+        # Create wizard and flower
+        wizard = Circle(radius=0.5, color=BLUE, fill_opacity=1).shift(LEFT*3)
+        wizard_label = Text("Wizard").next_to(wizard, DOWN)
+        
+        flower = VGroup(
+            Circle(radius=0.3, color=GREEN).shift(UP*0.3),
+            Circle(radius=0.2, color=YELLOW).shift(UP*0.3),
+            Line(UP*0.3, DOWN*1, color=GREEN)
+        ).shift(RIGHT*3)
+        flower_label = Text("Flower").next_to(flower, DOWN)
+        
+        # Create spell function
+        func_label = Text("cast_grow_spell()", color=YELLOW).shift(UP*2)
+        
+        # Animation
+        self.play(Create(wizard), Write(wizard_label))
+        self.play(Create(flower), Write(flower_label))
+        self.play(Write(func_label))
+        self.wait(1)
+        
+        # Cast spell multiple times
+        for i in range({count}):
+            # Create spell effect
+            spell = VGroup(
+                Star(color=PURPLE, fill_opacity=1).scale(0.3),
+                MathTex("\\star", color=PURPLE).scale(1.5)
+            )
+            
+            # Animate spell moving
+            self.play(
+                Create(spell.move_to(wizard.get_center())),
+                run_time=0.5
+            )
+            self.play(
+                spell.animate.move_to(flower.get_center()),
+                run_time=1
+            )
+            self.play(FadeOut(spell))
+            
+            # Grow flower
+            self.play(
+                flower.animate.scale(1.2),
+                run_time=0.5
+            )
+            self.wait(0.5)
+            
+            # Show function call
+            call_text = Text(f"cast_grow_spell()  #{i+1}", color=GREEN).shift(DOWN*2)
+            self.play(Write(call_text))
+            self.play(FadeOut(call_text))
+        
+        self.wait(2)
+        """
+    }
 }
 
 def analyze_story(story):
-    """Analyze story using simple NLP and identify programming concepts"""
+    """Analyze story and identify programming concepts"""
     story_lower = story.lower()
     detected_concepts = []
     
@@ -190,152 +462,109 @@ def analyze_story(story):
     return list(set(detected_concepts))
 
 def generate_animation_code(story, concepts):
-    """Generate Python animation code using free Hugging Face model"""
+    """Generate Python animation code based on story"""
     try:
-        # For Hugging Face Spaces, we'll use a simplified approach
-        # since we can't run complex AI models for free
-        
-        # Build a template-based code generator
-        characters = ["rabbit", "dragon", "cat", "dog", "knight", "wizard", "scientist", "pirate"]
-        actions = ["hop", "run", "fly", "jump", "cast", "collect", "change", "grow"]
-        
-        character = random.choice(characters)
-        action = random.choice(actions)
-        count = random.randint(2, 5)
+        # Choose a random character
+        character = random.choice(list(CHARACTERS.keys()))
+        char_details = CHARACTERS[character]
         
+        # Choose the most relevant concept
         concept = concepts[0] if concepts else "loop"
         
+        # Get template for the concept
+        template = ANIMATION_TEMPLATES.get(concept, ANIMATION_TEMPLATES["loop"])
+        
+        # Fill in template parameters
         if concept == "loop":
-            code = f"""# {story}
-import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
-
-fig, ax = plt.subplots(figsize=(8, 6))
-ax.set_xlim(0, 10)
-ax.set_ylim(0, 10)
-ax.set_title('{" ".join(story.split()[:5])}...')
-ax.set_facecolor('#f0f8ff')
-
-{character}_x = [2]
-{character}_y = [2]
-{character}_dot, = ax.plot({character}_x, {character}_y, 'o', markersize=20, color='orange')
-
-carrot_x = [8]
-carrot_y = [8]
-carrot_dot, = ax.plot(carrot_x, carrot_y, 'o', markersize=15, color='orange')
-
-def animate(frame):
-    # This is a loop that runs {count} times
-    if frame < {count}:
-        # Move the {character} closer to the target
-        new_x = {character}_x[-1] + 1.5
-        new_y = {character}_y[-1] + 1.5
-        {character}_x.append(new_x)
-        {character}_y.append(new_y)
-        {character}_dot.set_data({character}_x[-1], {character}_y[-1])
-    
-    return {character}_dot, carrot_dot
-
-ani = animation.FuncAnimation(fig, animate, frames={count+1}, interval=1000)
-plt.grid(True, linestyle='--', alpha=0.7)
-plt.show()
-"""
+            # Extract count from story
+            count = 3
+            for word in story.split():
+                if word.isdigit():
+                    count = min(int(word), 10)
+                    break
+            
+            code = template["pygame"].format(
+                character=character,
+                char_color=char_details["color"],
+                char_size=char_details["size"],
+                char_speed=char_details["speed"],
+                count=count
+            )
         elif concept == "conditional":
-            code = f"""# {story}
-import matplotlib.pyplot as plt
-import numpy as np
-
-fig, ax = plt.subplots(figsize=(8, 6))
-ax.set_xlim(0, 10)
-ax.set_ylim(0, 10)
-ax.set_title('{" ".join(story.split()[:5])}...')
-ax.set_facecolor('#f0f8ff')
-
-# This variable stores our condition
-is_unlocked = {'True' if random.choice([True, False]) else 'False'}
-
-# Draw treasure chest
-chest = plt.Rectangle((4, 4), 2, 2, fill=True, color='brown')
-ax.add_patch(chest)
-
-# Draw lock if not unlocked
-if not is_unlocked:
-    lock = plt.Rectangle((5, 6), 0.5, 0.8, fill=True, color='gray')
-    ax.add_patch(lock)
-    ax.text(5, 3, 'Locked! Find the key', fontsize=12, ha='center')
-else:
-    # Show open chest with treasure
-    chest.set_fill(False)
-    chest.set_edgecolor('brown')
-    chest.set_linestyle('--')
-    ax.text(5, 5, '$$$', fontsize=20, ha='center')
-    ax.text(5, 3, 'Treasure Acquired!', fontsize=12, ha='center')
-
-plt.grid(True, linestyle='--', alpha=0.7)
-plt.show()
-"""
+            condition = "True" if random.random() > 0.5 else "False"
+            code = template["pygame"].format(condition=condition)
+        elif concept == "function":
+            count = 3
+            for word in story.split():
+                if word.isdigit():
+                    count = min(int(word), 5)
+                    break
+            code = template["manim"].format(count=count)
         else:
-            code = f"""# {story}
-import matplotlib.pyplot as plt
-import numpy as np
-
-fig, ax = plt.subplots(figsize=(8, 6))
-ax.set_xlim(0, 10)
-ax.set_ylim(0, 10)
-ax.set_title('{" ".join(story.split()[:5])}...')
-ax.set_facecolor('#f0f8ff')
-
-# Draw the scene
-ax.text(5, 8, '✨ Your Story ✨', fontsize=20, ha='center')
-ax.text(5, 7, f'"{story[:50]}{"..." if len(story) > 50 else ""}"', 
-        fontsize=14, ha='center', wrap=True)
-
-# Draw coding concept icons
-y_pos = 5
-for concept in {concepts}:
-    details = {CONCEPTS}[concept]
-    ax.text(2, y_pos, details['emoji'], fontsize=30, ha='center')
-    ax.text(5, y_pos, details['name'], fontsize=16, ha='left')
-    y_pos -= 1
-
-ax.text(5, 2, 'Generated with Python!', fontsize=14, ha='center', style='italic')
-plt.grid(True, linestyle='--', alpha=0.7)
-plt.show()
-"""
+            # Default to loop animation
+            code = ANIMATION_TEMPLATES["loop"]["pygame"].format(
+                character=character,
+                char_color=char_details["color"],
+                char_size=char_details["size"],
+                char_speed=char_details["speed"],
+                count=3
+            )
         
         return code
     except Exception as e:
         return f"# Error generating code\nprint('Could not generate code: {str(e)}')"
 
-def create_matplotlib_animation(code):
-    """Create an animation using matplotlib"""
+def run_pygame_animation(code):
+    """Run PyGame animation code and generate GIF"""
     try:
-        # Create a namespace to execute the code
-        namespace = {}
-        exec(code, namespace)
+        # Create a temporary Python file
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode='w') as tmpfile:
+            tmpfile.write(code)
+            tmpfile_path = tmpfile.name
         
-        # Get the figure from the executed code
-        fig = plt.gcf()
+        # Run the animation script
+        subprocess.run(["python", tmpfile_path], check=True)
         
-        # Create a BytesIO object to save the animation
-        buf = io.BytesIO()
-        fig.savefig(buf, format='png')
-        buf.seek(0)
-        image = Image.open(buf)
+        # Check for generated GIF
+        if os.path.exists("animation.gif"):
+            return "animation.gif"
         
-        return image
+        return None
     except Exception as e:
         st.error(f"Animation error: {str(e)}")
         return None
 
-def generate_story_image(story):
-    """Generate a story image using a free API"""
+def run_manim_animation(code):
+    """Run Manim animation code and generate video"""
     try:
-        # For Hugging Face deployment, we'll use placeholders
-        # In a real deployment, you could use Hugging Face's diffusion models
+        # Create a temporary Python file
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode='w') as tmpfile:
+            tmpfile.write(code)
+            tmpfile_path = tmpfile.name
         
-        # Create a simple image with text
+        # Run Manim render
+        result = subprocess.run(
+            ["manim", "-ql", "-o", "animation", tmpfile_path],
+            capture_output=True,
+            text=True
+        )
+        
+        # Find the output file
+        output_dir = "media/videos"
+        if os.path.exists(output_dir):
+            for file in os.listdir(output_dir):
+                if file.startswith("animation") and file.endswith(".mp4"):
+                    return os.path.join(output_dir, file)
+        
+        return None
+    except Exception as e:
+        st.error(f"Manim error: {str(e)}")
+        return None
+
+def create_story_image(story):
+    """Create a story image with Matplotlib"""
+    try:
+        # Create figure
         fig, ax = plt.subplots(figsize=(10, 6))
         ax.set_facecolor('#f0f8ff')
         ax.set_xlim(0, 10)
@@ -396,8 +625,10 @@ def main():
         st.session_state.animation_code = ""
     if 'active_tab' not in st.session_state:
         st.session_state.active_tab = "story"
-    if 'animation_image' not in st.session_state:
-        st.session_state.animation_image = None
+    if 'animation_path' not in st.session_state:
+        st.session_state.animation_path = None
+    if 'animation_type' not in st.session_state:
+        st.session_state.animation_type = None
     
     # Create tabs
     tabs = st.empty()
@@ -419,7 +650,8 @@ def main():
             st.session_state.story = ""
             st.session_state.concepts = []
             st.session_state.animation_code = ""
-            st.session_state.animation_image = None
+            st.session_state.animation_path = None
+            st.session_state.animation_type = None
             st.session_state.active_tab = "story"
     
     # Story creation tab
@@ -449,13 +681,22 @@ def main():
                             story, st.session_state.concepts
                         )
                     
-                    with st.spinner("🎨 Creating your animation..."):
-                        st.session_state.animation_image = create_matplotlib_animation(
-                            st.session_state.animation_code
-                        )
+                    # Determine animation type
+                    if "manim" in st.session_state.animation_code:
+                        st.session_state.animation_type = "manim"
+                        with st.spinner("🎬 Rendering Manim animation (this may take a minute)..."):
+                            st.session_state.animation_path = run_manim_animation(
+                                st.session_state.animation_code
+                            )
+                    else:
+                        st.session_state.animation_type = "pygame"
+                        with st.spinner("🎬 Creating PyGame animation..."):
+                            st.session_state.animation_path = run_pygame_animation(
+                                st.session_state.animation_code
+                            )
                     
                     st.session_state.active_tab = "animation"
-                    st.experimental_rerun()
+                    st.rerun()
             
             # Show examples
             st.subheader("✨ Story Examples")
@@ -468,26 +709,41 @@ def main():
                 st.code('"If it rains, the cat stays inside, else it goes out"', language="text")
             with col3:
                 st.caption("Function Example")
-                st.code('"A wizard casts a spell to make flowers grow"', language="text")
+                st.code('"A wizard casts a spell to make flowers grow 3 times"', language="text")
     
     # Animation tab
     elif st.session_state.active_tab == "animation":
         st.header("🎬 Your Story Animation")
         
-        if not st.session_state.animation_image:
+        if not st.session_state.animation_path:
             st.warning("Please create a story first!")
             st.session_state.active_tab = "story"
-            st.experimental_rerun()
+            st.rerun()
         
         # Display animation
-        st.image(st.session_state.animation_image, use_column_width=True)
+        st.markdown(f"""
+        <div class="animation-container">
+            <h3 style="color: white; text-align: center;">"{st.session_state.story[:60]}{'...' if len(st.session_state.story) > 60 else ''}"</h3>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        try:
+            if st.session_state.animation_type == "pygame":
+                st.image(st.session_state.animation_path, use_container_width=True)
+            elif st.session_state.animation_type == "manim":
+                st.video(st.session_state.animation_path)
+        except Exception as e:
+            st.error(f"Couldn't display animation: {str(e)}")
+            story_image = create_story_image(st.session_state.story)
+            if story_image:
+                st.image(story_image, use_container_width=True)
         
         st.success("✨ Animation created successfully!")
         st.caption("This animation was generated with Python code based on your story!")
         
         if st.button("Reveal Coding Secrets!", use_container_width=True):
             st.session_state.active_tab = "concepts"
-            st.experimental_rerun()
+            st.rerun()
     
     # Concepts tab
     elif st.session_state.active_tab == "concepts":
@@ -513,7 +769,7 @@ def main():
         
         if st.button("See the Magic Code!", use_container_width=True):
             st.session_state.active_tab = "code"
-            st.experimental_rerun()
+            st.rerun()
     
     # Code tab
     elif st.session_state.active_tab == "code":
@@ -539,7 +795,7 @@ def main():
         if st.button("Create Another Story!", use_container_width=True):
             st.session_state.active_tab = "story"
             st.session_state.story = ""
-            st.experimental_rerun()
+            st.rerun()
 
 if __name__ == "__main__":
     main()