Updated Code

app.py

@@ -38,9 +38,7 @@ class ManimVideoGenerator:
         self.client = Groq(api_key=groq_api_key)
         self.available_models = {
             "llama-3.3-70b-versatile": "Llama 3.3 70B",
-            "llama3-8b-8192": "Llama 3 8B", 
-            "llama-3.1-8b-instant": "Llama 3.1 8B Instant",
-            "gemma2-9b-it": "Gemma 2 9B"
+            "llama3-8b-8192": "Llama 3 8B"
         }
         self.temp_dir = None
         self.metrics = MetricsCollector()
@@ -550,6 +548,14 @@ def process_video_generation(generator, user_prompt, selected_model, video_quali
                 if logs and st.checkbox("Show error details"):
                     st.text_area("Error Details", logs, height=200)
             
+            # Cleanup after everything is done
+            if temp_dir and os.path.exists(temp_dir):
+                try:
+                    shutil.rmtree(temp_dir)
+                    logger.info(f"Cleaned up temporary directory: {temp_dir}")
+                except Exception as e:
+                    logger.error(f"Error cleaning up temporary directory: {e}")
+            
     except Exception as e:
         error_info = ErrorHandler.get_user_friendly_error(type(e).__name__, str(e))
         st.markdown(f'<div class="error-box">❌ {error_info["user_message"]}</div>', 
@@ -562,6 +568,14 @@ def process_video_generation(generator, user_prompt, selected_model, video_quali
                 st.markdown(f"• {suggestion}")
         
         logger.error(f"Application error: {e}")
+        
+        # Cleanup in case of error
+        if 'temp_dir' in locals() and temp_dir and os.path.exists(temp_dir):
+            try:
+                shutil.rmtree(temp_dir)
+                logger.info(f"Cleaned up temporary directory after error: {temp_dir}")
+            except Exception as cleanup_error:
+                logger.error(f"Error cleaning up temporary directory after error: {cleanup_error}")
 
 def main():
     initialize_app()
@@ -597,18 +611,9 @@ def main():
     generator = ManimVideoGenerator(groq_api_key)
     
     # Render main interface
-    interface_result = render_main_interface()
-    
-    # Handle example selection or user input
-    if isinstance(interface_result[0], str) and not interface_result[1]:
-        # Example was selected
-        user_prompt = interface_result[0]
-        generate_button = True
-    else:
-        # Regular user input
-        user_prompt, generate_button = interface_result
+    user_prompt, generate_button = render_main_interface()
     
-    # Process generation if requested
+    # Process generation only if button is clicked and there's a prompt
     if generate_button and user_prompt and user_prompt.strip():
         process_video_generation(generator, user_prompt, selected_model, video_quality)
         generator.cleanup()

config/constants.py

@@ -1,24 +1,23 @@
-"""Application constants and enums."""
-
 from enum import Enum, auto
 from typing import Dict, List, Tuple
 
+# Quality levels
+LOW = "low_quality"
+MEDIUM = "medium_quality"
+
+# Model identifiers
+LLAMA_70B = "llama-3.3-70b-versatile"
+LLAMA_8B = "llama3-8b-8192"
+
 class VideoQuality(Enum):
-    """Video quality levels."""
     LOW = "low_quality"
     MEDIUM = "medium_quality"
-    HIGH = "high_quality"
-    PRODUCTION = "production_quality"
 
 class ModelType(Enum):
-    """Available AI models."""
     LLAMA_70B = "llama-3.3-70b-versatile"
     LLAMA_8B = "llama3-8b-8192"
-    MIXTRAL = "mixtral-8x7b-32768"
-    GEMMA = "gemma2-9b-it"
 
 class AnimationCategory(Enum):
-    """Categories of mathematical animations."""
     ALGEBRA = "algebra"
     GEOMETRY = "geometry"
     CALCULUS = "calculus"
@@ -28,7 +27,6 @@ class AnimationCategory(Enum):
     OTHER = "other"
 
 class ErrorType(Enum):
-    """Types of errors that can occur."""
     RENDERING_ERROR = auto()
     CODE_GENERATION_ERROR = auto()
     PROMPT_ERROR = auto()
@@ -64,26 +62,6 @@ FILE_CONSTANTS = {
     "LOG_FILE_NAME": "manimate.log"
 }
 
-# Example Prompts by Category
-EXAMPLE_PROMPTS: Dict[AnimationCategory, List[str]] = {
-    AnimationCategory.ALGEBRA: [
-        "Visualize solving x² + 3x - 4 = 0 using the quadratic formula",
-        "Show function transformations with f(x) = x² shifting and scaling"
-    ],
-    AnimationCategory.GEOMETRY: [
-        "Demonstrate the Pythagorean theorem with squares on triangle sides",
-        "Animate the construction of a regular pentagon using compass and straightedge"
-    ],
-    AnimationCategory.CALCULUS: [
-        "Show the concept of limits with a function approaching a value",
-        "Visualize area under curve using Riemann sums with rectangles"
-    ],
-    AnimationCategory.STATISTICS: [
-        "Animate the Central Limit Theorem with multiple distributions",
-        "Show correlation vs causation with scatter plot examples"
-    ]
-}
-
 # CSS Classes
 CSS_CLASSES = {
     "MAIN_HEADER": "main-header",
@@ -91,7 +69,19 @@ CSS_CLASSES = {
     "SUCCESS_BOX": "success-box",
     "ERROR_BOX": "error-box",
     "INFO_BOX": "info-box",
-    "METRIC_BOX": "metric-box"
+    "METRIC_BOX": "metric-box",
+    "header": """
+        text-align: center;
+        padding: 1rem 0;
+        background: linear-gradient(90deg, #667eea 7%, #764ba2 100%);
+        color: white;
+        border-radius: 10px;
+    """,
+    "container": """
+        max-width: 1200px;
+        margin: 0 auto;
+        padding: 2rem;
+    """
 }
 
 # CSS Styles
@@ -125,14 +115,18 @@ STATUS_MESSAGES = {
     "ERROR": "❌ Error occurred during generation"
 }
 
-def get_example_prompts(category: AnimationCategory) -> List[str]:
-    """Get example prompts for a specific category."""
-    return EXAMPLE_PROMPTS.get(category, [])
+# Application constants
+APP_CONSTANTS = {
+    "MAX_RENDER_TIME": 300,  # seconds
+    "MAX_PROMPT_LENGTH": 1000,
+    "MIN_PROMPT_LENGTH": 10,
+    "DEFAULT_VIDEO_QUALITY": VideoQuality.MEDIUM.value,
+    "TEMP_FILE_PREFIX": "manim_",
+    "LOG_FILE_NAME": "manimate.log"
+}
 
 def get_css_class(class_name: str) -> str:
-    """Get CSS class name by key."""
     return CSS_CLASSES.get(class_name, "")
 
 def get_status_message(key: str) -> str:
-    """Get status message by key."""
     return STATUS_MESSAGES.get(key, "") 

config/settings.py

@@ -1,5 +1,3 @@
-"""Application settings and configuration."""
-
 from pathlib import Path
 from typing import Dict, Any
 
@@ -29,18 +27,6 @@ AVAILABLE_MODELS = {
         "description": "Fast and efficient for simpler animations",
         "max_tokens": 8192,
         "temperature": 0.7
-    },
-    "mixtral-8x7b-32768": {
-        "name": "Mixtral 8x7B",
-        "description": "Creative model with large context window",
-        "max_tokens": 32768,
-        "temperature": 0.8
-    },
-    "gemma2-9b-it": {
-        "name": "Gemma 2 9B",
-        "description": "Efficient model for basic animations",
-        "max_tokens": 8192,
-        "temperature": 0.7
     }
 }
 
@@ -57,18 +43,6 @@ QUALITY_SETTINGS = {
         "description": "Medium Quality (Balanced)",
         "estimated_time": 180,  # seconds
         "resolution": "720p"
-    },
-    "high_quality": {
-        "flag": "-qh",
-        "description": "High Quality (Detailed)",
-        "estimated_time": 300,  # seconds
-        "resolution": "1080p"
-    },
-    "production_quality": {
-        "flag": "-qk",
-        "description": "Production Quality (Best)",
-        "estimated_time": 600,  # seconds
-        "resolution": "4K"
     }
 }
 
@@ -98,7 +72,6 @@ UI_SETTINGS = {
 }
 
 def get_setting(key: str, default: Any = None) -> Any:
-    """Get a setting value by key with optional default."""
     if key in APP_SETTINGS:
         return APP_SETTINGS[key]
     if key in UI_SETTINGS:
@@ -106,7 +79,6 @@ def get_setting(key: str, default: Any = None) -> Any:
     return default
 
 def update_setting(key: str, value: Any) -> None:
-    """Update a setting value."""
     if key in APP_SETTINGS:
         APP_SETTINGS[key] = value
     elif key in UI_SETTINGS:

config/space_config.py

@@ -1,5 +1,3 @@
-"""Configuration settings for Hugging Face Spaces deployment."""
-
 import os
 
 # Space-specific settings
@@ -8,9 +6,7 @@ SPACE_CONFIG = {
     "max_video_size_mb": 50,  # Maximum video size in MB
     "allowed_models": [
         "llama-3.3-70b-versatile",
-        "llama3-8b-8192",
-        "mixtral-8x7b-32768",
-        "gemma2-9b-it"
+        "llama3-8b-8192"
     ],
     "default_quality": "medium_quality",
     "cache_ttl": 3600,  # Cache time-to-live in seconds
@@ -58,6 +54,22 @@ UI_CONFIG = {
     "enable_error_reporting": True
 }
 
+AVAILABLE_MODELS = [
+    "llama-3.3-70b-versatile",
+    "llama3-8b-8192"
+]
+
+QUALITY_SETTINGS = {
+    "low_quality": {
+        "resolution": "480p",
+        "fps": 30
+    },
+    "medium_quality": {
+        "resolution": "720p",
+        "fps": 30
+    }
+}
+
 def get_space_config():
     """Get the current space configuration."""
     return {

core/generator.py

@@ -1,5 +1,3 @@
-"""Core video generation functionality."""
-
 import os
 import logging
 import tempfile
@@ -31,10 +29,8 @@ from utils.metrics_collector import MetricsCollector
 logger = logging.getLogger(__name__)
 
 class ManimVideoGenerator:
-    """Main class for generating Manim videos from prompts."""
     
     def __init__(self, groq_api_key: str):
-        """Initialize the Manim Video Generator with Groq API key."""
         self.client = Groq(api_key=groq_api_key)
         self.available_models = AVAILABLE_MODELS
         self.temp_dir = None
@@ -43,7 +39,6 @@ class ManimVideoGenerator:
         self.code_validator = CodeValidator()
         
     def enhance_prompt(self, user_prompt: str, model: str = DEFAULT_MODEL) -> str:
-        """Enhance the user prompt for better Manim code generation."""
         try:
             model_config = self.available_models[model]
             return self.prompt_manager.enhance_prompt(
@@ -59,7 +54,6 @@ class ManimVideoGenerator:
             return user_prompt
     
     def generate_manim_code(self, enhanced_prompt: str, model: str = DEFAULT_MODEL) -> str:
-        """Generate Manim code from the enhanced prompt."""
         try:
             model_config = self.available_models[model]
             return self.prompt_manager.generate_code(
@@ -75,12 +69,9 @@ class ManimVideoGenerator:
             raise
     
     def process_and_validate_code(self, raw_code: str) -> str:
-        """Process and validate the generated code."""
         try:
-            # Clean and validate code
             cleaned_code = self.code_validator.fix_common_issues(raw_code)
             
-            # Validate syntax and structure
             validation_result = self.code_validator.validate_code(cleaned_code)
             if not validation_result["is_valid"]:
                 raise ValueError(validation_result["error_message"])
@@ -92,7 +83,6 @@ class ManimVideoGenerator:
             raise
     
     def create_temp_directory(self) -> str:
-        """Create a temporary directory for Manim operations."""
         if self.temp_dir and os.path.exists(self.temp_dir):
             shutil.rmtree(self.temp_dir)
         
@@ -103,7 +93,6 @@ class ManimVideoGenerator:
         return self.temp_dir
     
     def save_code_to_file(self, code: str, temp_dir: str) -> str:
-        """Save the Manim code to a Python file."""
         code_file = os.path.join(temp_dir, FILE_CONSTANTS["SCENE_FILE_NAME"])
         try:
             with open(code_file, 'w', encoding='utf-8') as f:
@@ -120,7 +109,6 @@ class ManimVideoGenerator:
         temp_dir: str,
         quality: str = VideoQuality.MEDIUM.value
     ) -> Tuple[bool, str, str]:
-        """Render the Manim video."""
         from utils.renderer import VideoRenderer
         
         try:
@@ -139,7 +127,6 @@ class ManimVideoGenerator:
             return False, str(e), ""
     
     def cleanup(self) -> None:
-        """Clean up temporary files."""
         if self.temp_dir and os.path.exists(self.temp_dir):
             try:
                 shutil.rmtree(self.temp_dir)
@@ -149,12 +136,10 @@ class ManimVideoGenerator:
                 ErrorHandler.handle_error(ErrorType.SYSTEM_ERROR, str(e))
     
     def get_metrics_summary(self) -> Dict[str, Any]:
-        """Get a summary of generation metrics."""
         return self.metrics.get_summary()
     
     @property
     def model_options(self) -> Dict[str, str]:
-        """Get formatted model options for UI display."""
         return {
             model_id: f"{config['name']} ({config['description']})"
             for model_id, config in self.available_models.items()
@@ -162,7 +147,6 @@ class ManimVideoGenerator:
     
     @property
     def quality_options(self) -> Dict[str, str]:
-        """Get formatted quality options for UI display."""
         return {
             quality_id: config["description"]
             for quality_id, config in QUALITY_SETTINGS.items()

utils/metrics_collector.py

@@ -20,7 +20,10 @@ class MetricsCollector:
         self.failed_renders = 0
         self.render_times: List[float] = []
         self.error_counts = defaultdict(int)
-        self.quality_usage = defaultdict(int)
+        self.quality_usage = {
+            VideoQuality.LOW.value: 0,
+            VideoQuality.MEDIUM.value: 0
+        }
         self.scene_types = defaultdict(int)
         self.start_time = time.time()
     

utils/performance_optimizer.py

@@ -10,31 +10,29 @@ class PerformanceOptimizer:
     
     QUALITY_SETTINGS = {
         "low_quality": {
-            "flag": "-ql",
-            "resolution": "854x480",
-            "frame_rate": 15,
-            "description": "480p, 15fps - Fast rendering"
+            "resolution": "480p",
+            "fps": 30,
+            "description": "480p, 30fps - Fast rendering"
         },
         "medium_quality": {
-            "flag": "-qm", 
-            "resolution": "1280x720",
-            "frame_rate": 30,
-            "description": "720p, 30fps - Balanced"
-        },
-        "high_quality": {
-            "flag": "-qh",
-            "resolution": "1920x1080", 
-            "frame_rate": 60,
-            "description": "1080p, 60fps - High quality"
-        },
-        "production_quality": {
-            "flag": "-qp",
-            "resolution": "3840x2160",
-            "frame_rate": 60, 
-            "description": "4K, 60fps - Production ready"
+            "resolution": "720p",
+            "fps": 30,
+            "description": "720p, 30fps - Balanced quality"
         }
     }
     
+    # Performance thresholds
+    RENDER_TIME_THRESHOLDS = {
+        "low_quality": 60,
+        "medium_quality": 180
+    }
+    
+    # Memory usage thresholds (in GB)
+    MEMORY_THRESHOLDS = {
+        "low_quality": 4.0,
+        "medium_quality": 6.0
+    }
+    
     @classmethod
     def estimate_render_time(cls, quality: str, complexity: str = "medium") -> int:
         """Estimate rendering time in seconds"""
@@ -162,4 +160,11 @@ class PerformanceOptimizer:
         tips.append("Close other applications to free up system resources")
         tips.append("Ensure sufficient disk space for temporary files")
         
-        return tips
+        return tips
+
+    def optimize_quality(self, available_memory: float, estimated_render_time: float) -> str:
+        if available_memory < self.MEMORY_THRESHOLDS["low_quality"]:
+            return "low_quality"
+        if estimated_render_time > self.RENDER_TIME_THRESHOLDS["medium_quality"]:
+            return "low_quality"
+        return "medium_quality"

utils/ui_components.py

@@ -18,7 +18,7 @@ def initialize_app():
     .main-header {
         text-align: center;
         padding: 1rem 0;
-        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        background: linear-gradient(70deg, #667eea 47%, #764ba2 100%);
         color: white;
         border-radius: 10px;
         margin-bottom: 2rem;
@@ -60,7 +60,7 @@ def initialize_app():
 def render_header():
     st.markdown("""
     <div class="main-header">
-        <h1>🎬 Manim Video Generator</h1>
+        <h1>🎬 Manimate: Video Generator</h1>
         <p>Transform your ideas into mathematical animations</p>
     </div>
     """, unsafe_allow_html=True)
@@ -75,10 +75,8 @@ def render_sidebar():
                 st.write(f"{status} {key.replace('_', ' ').title()}: {value}")
         
         model_options = {
-            "llama-3.3-70b-versatile": "Llama 3.3 70B (Recommended)",
-            "llama3-8b-8192": "Llama 3 8B (Fast)",
-            "mixtral-8x7b-32768": "Mixtral 8x7B (Creative)",
-            "gemma2-9b-it": "Gemma 2 9B (Efficient)"
+            "llama-3.3-70b-versatile": "Llama 3.3 70B (Most Capable)",
+            "llama3-8b-8192": "Llama 3 8B (Fast)"
         }
         selected_model = st.selectbox(
             "AI Model",
@@ -143,9 +141,11 @@ def render_main_interface():
     user_prompt = st.text_area(
         "Describe the mathematical animation you want to create:",
         height=150,
-        placeholder="Example: Create an animation showing the derivative of x² as the slope of tangent lines, with smooth transitions and clear labeling",
+        placeholder="Example: Create an animation showing the derivation of Pythagorean theorem, with smooth transitions and clear labeling",
         help="Be as descriptive as possible for best results. Mention specific mathematical concepts, colors, and visual elements."
     )
+    
+    # Show category and complexity info if there's input
     if user_prompt:
         category = PromptTemplates.detect_category(user_prompt)
         complexity = "complex" if len(user_prompt) > 100 else "medium"
@@ -154,10 +154,11 @@ def render_main_interface():
             st.info(f"📂 Detected category: **{category.title()}**")
         with col_info2:
             st.info(f"🎯 Complexity: **{complexity.title()}**")
+    
+    # Add a separate Generate button
     generate_button = st.button("🚀 Generate Animation", type="primary", disabled=not user_prompt.strip())
     
-    # example_prompt = render_examples()
-    return user_prompt, generate_button, None
+    return user_prompt, generate_button
 
 def render_footer(generator=None):
     st.markdown("---")