Upload 8 files

.gitignore

@@ -0,0 +1,55 @@
+# Environment files
+.env
+.env.local
+.env.production
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Generated videos
+*.mp4
+*.mov
+*.avi
+
+# Manim outputs
+media/
+new*.py
+
+# Temporary files
+*.tmp
+*.temp
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Logs
+*.log
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST

DEPLOYMENT.md

@@ -0,0 +1,105 @@
+# 🚀 Deployment Guide for Hugging Face Spaces
+
+## Files Created for Deployment
+
+1. **app.py** - Main Gradio application
+2. **README.md** - Space configuration and documentation
+3. **requirements.txt** - Python dependencies
+4. **packages.txt** - System dependencies for Manim
+5. **.gitignore** - Files to exclude from git
+6. **test_deployment.py** - Local testing script
+
+## Step-by-Step Deployment Instructions
+
+### 1. Create a New Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose:
+   - **Space name**: `ai-video-generator` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Gradio
+   - **Hardware**: CPU Basic (free tier) or GPU if you have Pro subscription
+
+### 2. Upload Files
+
+Upload all the files from your video_generator folder:
+- `app.py`
+- `README.md`
+- `requirements.txt`
+- `packages.txt`
+- `.gitignore`
+
+**DO NOT upload**:
+- `.env` file (contains your API key)
+- `video_generator.py` (original file, not needed)
+
+### 3. Set Environment Variables
+
+1. Go to your Space settings
+2. Click on "Variables and secrets"
+3. Add a new secret:
+   - **Name**: `GEMINI_API_KEY`
+   - **Value**: Your actual Gemini API key (from your .env file)
+
+### 4. Wait for Build
+
+- The space will automatically build and install dependencies
+- This may take 5-15 minutes due to Manim installation
+- Check the build logs for any errors
+
+### 5. Test the Application
+
+1. Once built, test with a simple topic like "Introduction to Python"
+2. Check if videos generate correctly
+3. Verify the interface works smoothly
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+1. **Build Timeout**
+   - Manim installation can be slow
+   - Try using a smaller requirements.txt with fewer versions specified
+
+2. **Memory Issues**
+   - Use shorter video durations (1 minute)
+   - Consider upgrading to GPU hardware
+
+3. **API Key Issues**
+   - Double-check the secret name is exactly `GEMINI_API_KEY`
+   - Verify the API key is valid and has quota
+
+4. **Video Generation Fails**
+   - Check the generation logs in the interface
+   - Manim syntax might need adjustment for the cloud environment
+
+## Alternative Deployment (GitHub → HF Spaces)
+
+If you prefer using Git:
+
+1. Create a GitHub repository
+2. Push all files (except .env)
+3. Connect the repository to Hugging Face Spaces
+4. Set the API key in Spaces secrets
+
+## Performance Tips
+
+1. **Use shorter durations** (1-2 minutes max)
+2. **Simple topics** work better than complex ones
+3. **Monitor usage** to stay within API limits
+4. **Consider caching** for frequently requested topics
+
+## Security Notes
+
+- Never commit API keys to public repositories
+- Use Hugging Face Spaces secrets for sensitive data
+- The .gitignore file excludes sensitive files
+
+## Support
+
+If you encounter issues:
+1. Check the Space logs
+2. Verify all dependencies in requirements.txt
+3. Test locally first with test_deployment.py
+4. Consider the Hugging Face Spaces documentation

DEPLOYMENT_SUMMARY.md

@@ -0,0 +1,66 @@
+# 🎬 AI Video Generator - Deployment Summary
+
+## ✅ Files Created for Hugging Face Spaces
+
+### Core Application Files
+- **`app.py`** - Main Gradio application with AI video generation
+- **`requirements.txt`** - Python dependencies optimized for HF Spaces
+- **`packages.txt`** - System dependencies for Manim
+- **`README.md`** - Space configuration and documentation
+
+### Supporting Files
+- **`.gitignore`** - Excludes sensitive and unnecessary files
+- **`DEPLOYMENT.md`** - Complete deployment instructions
+- **`test_deployment.py`** - Local testing script
+
+## 🚀 Ready for Deployment!
+
+Your video generator is now ready to deploy to Hugging Face Spaces. Here's what it includes:
+
+### Features
+- 🤖 AI-powered content generation using Google Gemini
+- 🎨 Professional Manim animations with clean presentation style
+- ⏱️ Customizable video duration (1-3 minutes)
+- 🎯 Educational focus with various topic support
+- 📱 Modern Gradio web interface
+- ⚡ Optimized for cloud deployment
+
+### Key Improvements Made
+1. **Stability**: Using stable model versions and error handling
+2. **Performance**: Reduced complexity and added timeouts
+3. **User Experience**: Better interface with status updates
+4. **Cloud Ready**: Proper environment variable handling
+5. **Error Handling**: Comprehensive error messages and fallbacks
+
+## 📋 Next Steps
+
+1. **Create Hugging Face Space**
+   - Go to https://huggingface.co/spaces
+   - Create new Gradio space
+   - Upload all files (except .env)
+
+2. **Set API Key**
+   - In Space settings → Variables and secrets
+   - Add secret: `GEMINI_API_KEY` = your actual API key
+
+3. **Wait for Build**
+   - Initial build takes 10-15 minutes
+   - Manim installation is the longest part
+
+4. **Test and Share**
+   - Try generating a simple video
+   - Share your space with others!
+
+## 🔧 Local Testing
+
+Run `python test_deployment.py` to verify dependencies before deployment.
+
+## 📞 Support
+
+If you encounter issues:
+- Check DEPLOYMENT.md for detailed troubleshooting
+- Verify API key is set correctly
+- Monitor Space build logs for errors
+- Start with simple topics for testing
+
+**Your AI Video Generator is ready for the world! 🌟**

app.py

@@ -0,0 +1,273 @@
+import gradio as gr
+import google.generativeai as genai
+import os
+import re
+import subprocess
+import tempfile
+import shutil
+from pathlib import Path
+import sys
+
+# Check if API key is available
+api_key = os.getenv("GEMINI_API_KEY")
+if not api_key:
+    print("⚠️ Warning: GEMINI_API_KEY not found in environment variables")
+    print("Please set your Gemini API key in the Hugging Face Spaces secrets")
+
+# Configure Gemini API
+genai.configure(api_key=api_key)
+
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-flash",  # Using more stable model for deployment
+    generation_config={
+        "temperature": 0.3,
+        "top_p": 0.95,
+        "top_k": 40,
+        "max_output_tokens": 8000,  # Reduced for better performance
+    }
+)
+
+def generate_video(topic, duration_minutes=1):
+    if not api_key:
+        return None, "❌ Error: GEMINI_API_KEY not configured. Please set it in Hugging Face Spaces secrets."
+    
+    try:
+        # Step 1: Generate plan for Manim animation
+        planning_prompt = f"""
+You are a professional with deep expertise in Manim CE 0.18.0.
+
+Your task is to design a presentation-style video using Manim for the topic: "{topic}"
+
+Guidelines:
+- The video should consist of **slides of text** with **smooth transitions** between them.
+- Structure the scene logically with 3-5 main points maximum.
+- Target duration: {duration_minutes} minute(s).
+- Use **simple text objects only**, no equations, graphs, or complex animations.
+- Keep text concise and readable.
+- Include details like:
+    - Text to be shown (keep it short and clear)
+    - When to fade in/out
+    - Slide duration (2-4 seconds per slide)
+    - Transitions (FadeIn, FadeOut, Transform)
+- Do not output any code here — only the **presentation plan**, step by step.
+
+Output Format:
+Scene 1:
+- Text: "Title: {topic}"
+- Action: FadeIn
+- Duration: 3 seconds
+
+Scene 2:
+- Text: "Key Point 1: [brief description]"
+- Action: Transform from previous
+- Duration: 4 seconds
+...
+"""
+
+        plan_response = model.generate_content(planning_prompt)
+        plan = plan_response.text.strip()
+
+        # Step 2: Generate Manim code based on the plan
+        code_prompt = f"""
+Using this animation plan:
+
+{plan}
+
+Write a complete Manim CE 0.18.0 compatible Python file with a class called `VideoScene` that inherits from Scene.
+
+Critical Requirements:
+- Import all necessary modules: from manim import *
+- Use ONLY basic text objects and simple transitions
+- Background should be WHITE: self.camera.background_color = WHITE
+- Text should be BLACK for contrast
+- Keep text size reasonable (font_size=24 to 36)
+- Use FadeIn, FadeOut, and Transform only
+- Add self.clear() between slides to avoid overlapping text
+- Include proper self.wait() durations
+- Make sure the class is properly indented and structured
+- NO complex animations, NO equations, NO images
+- Keep it simple and clean
+
+Example structure:
+```python
+from manim import *
+
+class VideoScene(Scene):
+    def construct(self):
+        self.camera.background_color = WHITE
+        
+        # Title slide
+        title = Text("Your Title", font_size=36, color=BLACK)
+        self.play(FadeIn(title))
+        self.wait(3)
+        self.play(FadeOut(title))
+        self.clear()
+        
+        # Next slide...
+```
+
+Output: Just the complete Python code, no explanations.
+"""
+
+        final_code = model.generate_content(code_prompt)
+        raw_code = final_code.text.strip()
+
+        # Clean the code
+        cleaned_code = re.sub(r"^(```|''')python\s*", "", raw_code)
+        cleaned_code = re.sub(r"(```|''')\s*$", "", cleaned_code)
+
+        # Create temporary directory for this generation
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Save the generated code
+            manim_file = temp_path / "generated_video.py"
+            with open(manim_file, "w", encoding="utf-8") as f:
+                f.write(cleaned_code)
+
+            # Run manim to generate video with error handling
+            try:
+                # Use low quality for faster generation in cloud environment
+                result = subprocess.run([
+                    "manim", "-pql", "--fps", "15", str(manim_file), "VideoScene"
+                ], 
+                cwd=temp_dir,
+                capture_output=True, 
+                text=True, 
+                check=True,
+                timeout=120  # 2 minute timeout
+                )
+                
+                # Find the generated video file
+                media_dir = temp_path / "media"
+                video_files = list(media_dir.rglob("*.mp4"))
+                
+                if video_files:
+                    video_file = video_files[0]
+                    
+                    # Copy to a location accessible by Gradio
+                    output_file = f"video_{abs(hash(topic)) % 10000}.mp4"
+                    shutil.copy2(video_file, output_file)
+                    
+                    success_msg = f"✅ Video generated successfully!\n\n**Plan:**\n{plan}\n\n**Generated Code:**\n```python\n{cleaned_code}\n```"
+                    return output_file, success_msg
+                else:
+                    error_msg = f"❌ No video file found after generation.\n\n**Plan:**\n{plan}\n\n**Generated Code:**\n```python\n{cleaned_code}\n```\n\n**Manim Output:**\n{result.stdout}"
+                    return None, error_msg
+                    
+            except subprocess.TimeoutExpired:
+                return None, f"❌ Video generation timed out. Try a shorter duration or simpler topic.\n\n**Plan:**\n{plan}"
+            except subprocess.CalledProcessError as e:
+                error_msg = f"❌ Manim generation failed:\n{e.stderr}\n\n**Plan:**\n{plan}\n\n**Generated Code:**\n```python\n{cleaned_code}\n```"
+                return None, error_msg
+                
+    except Exception as e:
+        return None, f"❌ Unexpected error: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="AI Video Generator", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎬 AI Video Generator
+    
+    Generate educational videos using AI and Manim animations. Simply enter a topic and get a professional presentation-style video!
+    
+    **Features:**
+    - 🤖 AI-powered content generation using Gemini
+    - 🎨 Professional Manim animations  
+    - ⏱️ Customizable duration (1-3 minutes)
+    - 📱 Clean presentation style
+    
+    **Note:** Video generation may take 1-3 minutes depending on complexity.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            topic_input = gr.Textbox(
+                label="📝 Video Topic",
+                placeholder="Enter an educational topic (e.g., 'Introduction to Python', 'Basic Math Concepts')",
+                value="Introduction to Python Programming",
+                lines=2
+            )
+            
+            duration_input = gr.Slider(
+                minimum=1,
+                maximum=3,
+                value=1,
+                step=1,
+                label="⏱️ Duration (minutes)",
+                info="Shorter durations generate faster"
+            )
+            
+            generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("""
+            ### 💡 Tips for Best Results:
+            - Use clear, educational topics
+            - Avoid overly complex subjects
+            - Shorter durations work better
+            - Be patient - generation takes time
+            
+            ### 🎯 Great Topic Examples:
+            - "Introduction to Python"
+            - "Basic Data Structures" 
+            - "How Photosynthesis Works"
+            - "Understanding Fractions"
+            - "Solar System Overview"
+            """)
+    
+    with gr.Row():
+        with gr.Column():
+            video_output = gr.Video(
+                label="🎥 Generated Video",
+                height=400
+            )
+        
+        with gr.Column():
+            log_output = gr.Textbox(
+                label="📋 Generation Details", 
+                lines=15, 
+                max_lines=25,
+                show_copy_button=True,
+                placeholder="Generation logs and AI-created content will appear here..."
+            )
+    
+    # Progress indicator
+    with gr.Row():
+        status_text = gr.Textbox(
+            label="📊 Status",
+            value="Ready to generate video",
+            interactive=False
+        )
+    
+    def update_status(message):
+        return message
+    
+    def generate_with_status(topic, duration):
+        yield None, "🔄 Starting video generation...", "🔄 Initializing AI content creation..."
+        
+        try:
+            result_video, result_log = generate_video(topic, duration)
+            
+            if result_video:
+                yield result_video, result_log, "✅ Video generated successfully!"
+            else:
+                yield None, result_log, "❌ Video generation failed"
+                
+        except Exception as e:
+            yield None, f"❌ Error: {str(e)}", "❌ Generation failed with error"
+    
+    generate_btn.click(
+        fn=generate_with_status,
+        inputs=[topic_input, duration_input],
+        outputs=[video_output, log_output, status_text],
+        show_progress=True
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

packages.txt

@@ -0,0 +1,12 @@
+ffmpeg
+libcairo2-dev
+libpango1.0-dev
+libglib2.0-dev
+libxml2-dev
+libgdk-pixbuf2.0-dev
+libgirepository1.0-dev
+libjpeg-dev
+libpng-dev
+zlib1g-dev
+pkg-config
+build-essential

requirements.txt

@@ -0,0 +1,9 @@
+gradio==4.44.0
+manim==0.18.1
+google-generativeai==0.8.3
+numpy==1.24.3
+pillow==10.0.1
+scipy==1.11.4
+matplotlib==3.7.2
+pycairo==1.25.1
+manimpango==0.5.0

test_deployment.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the video generator works locally before deployment
+"""
+
+import os
+import sys
+from pathlib import Path
+
+def test_imports():
+    """Test if all required packages can be imported"""
+    try:
+        import gradio as gr
+        print("✅ Gradio imported successfully")
+        
+        import google.generativeai as genai
+        print("✅ Google Generative AI imported successfully")
+        
+        import manim
+        print("✅ Manim imported successfully")
+        
+        import numpy
+        print("✅ NumPy imported successfully")
+        
+        return True
+    except ImportError as e:
+        print(f"❌ Import error: {e}")
+        return False
+
+def test_api_key():
+    """Test if API key is available"""
+    api_key = os.getenv("GEMINI_API_KEY")
+    if api_key:
+        print("✅ GEMINI_API_KEY found")
+        return True
+    else:
+        print("⚠️ GEMINI_API_KEY not found - set it in environment variables")
+        return False
+
+def test_manim():
+    """Test if Manim can run a simple scene"""
+    try:
+        from manim import Scene, Text, FadeIn
+        print("✅ Manim core classes imported successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Manim test failed: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("🧪 Running pre-deployment tests...\n")
+    
+    all_tests = [
+        ("Import Test", test_imports),
+        ("API Key Test", test_api_key),
+        ("Manim Test", test_manim),
+    ]
+    
+    results = []
+    for test_name, test_func in all_tests:
+        print(f"Running {test_name}...")
+        result = test_func()
+        results.append(result)
+        print()
+    
+    if all(results):
+        print("🎉 All tests passed! Ready for deployment to Hugging Face Spaces")
+        return 0
+    else:
+        print("❌ Some tests failed. Please fix the issues before deployment")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

video_generator.py

@@ -0,0 +1,112 @@
+import google.generativeai as genai
+import os
+import re
+import subprocess
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure Gemini API with environment variable
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+model = genai.GenerativeModel(
+    model_name="gemini-2.5-pro",
+    generation_config={
+        "temperature": 0.3,
+        "top_p": 0.95,
+        "top_k": 40,
+        "max_output_tokens": 20000,
+    }
+)
+
+task="""Advanced DSA Concepts
+"""
+# Step 1: Generate plan for Manim animation
+planning_prompt = f"""
+You are a professional with deep expertise in Manim CE 0.18.0.
+
+Your task is to design a presentation-style video using Manim for the topic: "{task}"
+
+ Guidelines:
+- The video should consist of **slides of text** with **smooth transitions** between them.
+- Structure the scene logically.
+-I just want content for 1 minute only.
+- Use **simple text objects only**, no equations, graphs, or images.
+- Include details like:
+    - Text to be shown
+    - When to fade in/out
+    - Slide duration
+    - Transitions (e.g., `FadeIn`, `FadeOut`, `Transform`)
+- Do not output any code here — only the **presentation plan**, step by step.
+
+ Output Format:
+Scene 1:
+- Text: "Title Slide: Second World War"
+- Action: FadeIn
+- Duration: 3 seconds
+...
+
+"""
+
+plan_response = model.generate_content(planning_prompt)
+plan = plan_response.text.strip()
+
+# Step 2: Generate Manim code based on the plan
+code_prompt = f"""
+Using this animation plan:
+
+{plan}
+
+Write a full Manim CE 0.18.0 compatible class called `Video`.
+
+ Important Instructions:
+- Style it like a **PowerPoint presentation**: clean layout, one idea per slide.
+-You can change the background to white&black glassmorphism and text to black also make it look more professional.
+- Only use **text and transitions** (no math or images).
+- Each slide should be a simple text message with appropriate **FadeIn, FadeOut, or Transform** effects.
+- Do NOT use deprecated methods like `.to_edge()` or `.move_to(ORIGIN)` unnecessarily.
+- Use `self.wait()` to control slide durations.
+- Add brief pauses between scenes to simulate human-like pacing.
+
+ High Priority:
+-Text shouldn't merge with other text.
+- Strictly use Manim CE 0.18.0 syntax.
+- No explanations. Just return the final code block.
+
+Output: Just the Python code for the Manim scene.
+
+"""
+
+final_code = model.generate_content(code_prompt)
+print(final_code.text.strip())
+# Get the LLM output
+raw_code = final_code.text.strip()
+
+# Remove leading ```python or ``` and trailing ``` if present
+# Also handles '''python and ''' for safety
+cleaned_code = re.sub(r"^(```|''')python\s*", "", raw_code)
+cleaned_code = re.sub(r"(```|''')\s*$", "", cleaned_code)
+
+# Set base filename
+base_filename = "new"
+extension = ".py"
+i = 0
+
+# Find next available filename
+while os.path.exists(f"{base_filename}{i}{extension}"):
+    i += 1
+
+filename = f"{base_filename}{i}{extension}"
+
+# Save cleaned code
+with open(filename, "w", encoding="utf-8") as f:
+    f.write(cleaned_code)
+
+print(f"Code saved to {filename}")
+
+try:
+    print(f"🚀 Running {filename} ...\n")
+    subprocess.run(["manim", "-pql", filename, "Video"], check=True)
+except subprocess.CalledProcessError as e:
+    print(f"❌ Error running {filename}:\n{e}")