Update app.py

app.py

@@ -7,13 +7,20 @@ import shutil
 from datetime import datetime
 import traceback
 import json
-import ast 
+import ast
 import re
-import textwrap
-from manim import *
+import html
+import unicodedata
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+import edge_tts
+from pydub import AudioSegment
+from pydub.effects import normalize
+from mutagen.mp3 import MP3
 
 app = Flask(__name__)
-CORS(app)  # Enable CORS for all routes
+CORS(app)
 
 # Configuration
 BASE_DIR = "/app"
@@ -23,27 +30,13 @@ AUDIO_DIR = os.path.join(BASE_DIR, "sound")
 os.makedirs(MEDIA_DIR, exist_ok=True)
 os.makedirs(TEMP_DIR, exist_ok=True)
 os.makedirs(AUDIO_DIR, exist_ok=True)
+
 # API Key for security (optional)
 API_KEY = "rkmentormindzofficaltokenkey12345"
 
-
-    
-import re
-import html
-import unicodedata
-import tempfile
-import os
-import asyncio
-from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
-from functools import lru_cache
-import edge_tts
-from pydub import AudioSegment
-from pydub.effects import normalize
-from mutagen.mp3 import MP3
-
 VOICE_EN = "en-IN-NeerjaNeural"
 
-# Pre-compiled regex patterns for speed (compiled once, reused many times)
+# Pre-compiled regex patterns for speed
 URL_PATTERN = re.compile(r'https?://[^\s<>"\']+|www\.[^\s<>"\']+')
 TAG_PATTERN = re.compile(r'<[^>]*>|[<>]')
 BRACKET_PATTERN = re.compile(r'[\{\}\[\]]')
@@ -52,40 +45,40 @@ WHITESPACE_PATTERN = re.compile(r'\s+')
 SENTENCE_PATTERN = re.compile(r'(?<=[.!?])\s+')
 SUB_PATTERN = re.compile(r'(?<=[,;:])\s+')
 
-@lru_cache(maxsize=1024)  # Cache cleaned text to avoid re-processing
+
+@lru_cache(maxsize=1024)
 def clean_text_for_tts(text):
     """Cleans text before TTS with optimized regex and caching."""
     if not text:
         return ""
     text = str(text).strip()
     text = html.unescape(text)
-    
-    # Use pre-compiled patterns (much faster)
+
     text = URL_PATTERN.sub('', text)
     text = TAG_PATTERN.sub('', text)
     text = BRACKET_PATTERN.sub('', text)
     text = SPECIAL_CHAR_PATTERN.sub('', text)
     text = text.replace('\\n', ' ').replace('\\t', ' ').replace('\\r', ' ')
-    
-    # Batch remove keywords (faster than multiple re.sub calls)
+
     for keyword in ['voice', 'speak', 'prosody', 'ssml', 'xmlns']:
         text = text.replace(keyword, '').replace(keyword.upper(), '')
-    
+
     text = unicodedata.normalize('NFKD', text)
     text = WHITESPACE_PATTERN.sub(' ', text)
     return text.strip()
 
+
 async def generate_safe_audio(text, voice, semaphore):
     """Generate clean audio with rate limiting."""
-    async with semaphore:  # Limit concurrent TTS requests
+    async with semaphore:
         cleaned_text = clean_text_for_tts(text)
         if not cleaned_text:
             return None
-        
+
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
         fname = temp_file.name
         temp_file.close()
-        
+
         try:
             comm = edge_tts.Communicate(cleaned_text, voice=voice)
             await comm.save(fname)
@@ -93,24 +86,28 @@ async def generate_safe_audio(text, voice, semaphore):
         except Exception as e:
             print(f"Error generating audio: {e}")
             if os.path.exists(fname):
-                os.unlink(fname)
+                try:
+                    os.unlink(fname)
+                except:
+                    pass
             return None
 
+
 @lru_cache(maxsize=256)
 def smart_text_chunking(text, max_chars=80):
     """Cached text chunking for speed."""
     text = clean_text_for_tts(text)
     if not text:
-        return tuple()  # Return tuple for hashability (required by lru_cache)
-    
+        return tuple()
+
     sentences = SENTENCE_PATTERN.split(text)
     chunks = []
-    
+
     for sentence in sentences:
         sentence = sentence.strip()
         if not sentence:
             continue
-        
+
         if len(sentence) <= max_chars:
             chunks.append(sentence)
         else:
@@ -119,7 +116,7 @@ def smart_text_chunking(text, max_chars=80):
                 part = part.strip()
                 if not part:
                     continue
-                    
+
                 if len(part) <= max_chars:
                     chunks.append(part)
                 else:
@@ -135,109 +132,105 @@ def smart_text_chunking(text, max_chars=80):
                             current_chunk = word
                     if current_chunk:
                         chunks.append(current_chunk.strip())
-    
+
     return tuple(chunk for chunk in chunks if chunk.strip())
 
+
 def process_audio_segment_fast(audio_file):
     """Fast audio processing in separate thread."""
     try:
+        if not os.path.exists(audio_file):
+            return None
+
         segment = AudioSegment.from_file(audio_file)
         segment = normalize(segment)
-        
-        # Only strip silence for longer segments
+
         if len(segment) > 200:
             try:
                 segment = segment.strip_silence(silence_len=50, silence_thresh=-40)
             except:
-                pass  # Skip if fails
-        
+                pass
+
         return segment
     except Exception as e:
         print(f"Warning: Error processing audio segment: {e}")
         return None
     finally:
-        # Cleanup temp file immediately
         try:
             if os.path.exists(audio_file):
                 os.unlink(audio_file)
         except:
             pass
 
+
 async def bilingual_tts_optimized(text, output_file="audio0.mp3", VOICE_TA=None, max_concurrent=10):
     """Ultra-optimized bilingual TTS with parallel processing."""
     print("Starting optimized bilingual TTS processing...")
-    
+
     try:
         chunks = smart_text_chunking(text)
         if not chunks:
             print("Error: No valid text chunks after cleaning")
             return None
-        
+
         print(f"Processing {len(chunks)} text chunks with max {max_concurrent} concurrent requests...")
-        
+
         is_bilingual_tamil = VOICE_TA is not None and "ta-IN" in VOICE_TA
-        
-        # Semaphore to limit concurrent TTS requests (prevents rate limiting)
+
         semaphore = asyncio.Semaphore(max_concurrent)
-        
-        # Prepare all tasks
+
         tasks = []
         for i, chunk in enumerate(chunks):
             is_tamil = any('\u0B80' <= char <= '\u0BFF' for char in chunk)
             voice = VOICE_TA if (is_bilingual_tamil and is_tamil) else (VOICE_TA or VOICE_EN)
             tasks.append(generate_safe_audio(chunk, voice, semaphore))
-        
-        # Generate all audio files concurrently
+
         audio_files = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        # Filter successful files
-        processed_audio_files = [f for f in audio_files if isinstance(f, str) and f]
-        
+
+        processed_audio_files = [f for f in audio_files if isinstance(f, str) and f and os.path.exists(f)]
+
         if not processed_audio_files:
             print("Error: No audio was successfully generated")
             return None
-        
+
         print(f"Successfully generated {len(processed_audio_files)} audio segments")
-        
-        # Process audio segments in parallel using ThreadPoolExecutor
+
         with ThreadPoolExecutor(max_workers=min(len(processed_audio_files), 8)) as executor:
             audio_segments = list(executor.map(process_audio_segment_fast, processed_audio_files))
-        
-        # Filter out None segments
+
         audio_segments = [seg for seg in audio_segments if seg is not None]
-        
+
         if not audio_segments:
             print("Error: No audio segments were successfully processed")
             return None
-        
-        # Merge audio segments (fast concatenation)
+
         print("Merging audio segments...")
         merged_audio = audio_segments[0]
         pause = AudioSegment.silent(duration=200)
-        
+
         for segment in audio_segments[1:]:
             merged_audio += pause + segment
-        
-        # Apply final processing (compression and normalization)
+
         print("Applying final audio processing...")
         merged_audio = merged_audio.compress_dynamic_range(
-            threshold=-20.0, 
-            ratio=4.0, 
-            attack=5.0, 
+            threshold=-20.0,
+            ratio=4.0,
+            attack=5.0,
             release=50.0
         )
         merged_audio = normalize(merged_audio)
-        
-        # Export with high quality
+
         merged_audio.export(output_file, format="mp3", bitrate="192k")
-        print(f"✅ Audio successfully generated: {output_file}")
-        
+        print(f"✅ Audio successfully generated: {output_file}")
+
         return output_file
-        
+
     except Exception as main_error:
         print(f"Main error in bilingual TTS: {main_error}")
+        traceback.print_exc()
         return None
 
+
 async def generate_tts_optimized(id, lines, lang):
     """Optimized TTS generation function."""
     voice = {
@@ -274,82 +267,60 @@ async def generate_tts_optimized(id, lines, lang):
         "Czech": "cs-CZ-VlastaNeural",
         "Hungarian": "hu-HU-NoemiNeural"
     }
-    
+
     audio_name = f"audio{id}.mp3"
     audio_path = os.path.join(AUDIO_DIR, audio_name)
-    
+
     if "&&&" in lang:
         listf = lang.split("&&&")
         text = listf[0].strip()
-        lang_name = listf[1].strip()
+        lang_name = listf[1].strip() if len(listf) > 1 else "English"
         voice_to_use = voice.get(lang_name, VOICE_EN)
     else:
-        text = lines[id]
+        text = lines[id] if isinstance(lines, (list, tuple)) and id < len(lines) else str(lines)
         voice_to_use = voice.get(lang, VOICE_EN)
-    
-    # Increase max_concurrent for more speed (adjust based on your system)
+
     output = await bilingual_tts_optimized(text, audio_path, voice_to_use, max_concurrent=15)
-    
+
     if output and os.path.exists(audio_path):
-        audio = MP3(audio_path)
-        duration = audio.info.length
-        return duration, audio_path
-    
-    return None , None
+        try:
+            audio = MP3(audio_path)
+            duration = audio.info.length
+            return duration, audio_path
+        except Exception as e:
+            print(f"Error reading audio file: {e}")
+            return None, None
+
+    return None, None
+
 
 def audio_func(id, lines, lang):
     """Synchronous wrapper for audio generation."""
-    return asyncio.run(generate_tts_optimized(id, lines, lang))
-
-def make_wrapped_paragraph(content, max_width, color, font, font_size, line_spacing, align_left=True):
-    """
-    Build a vertically stacked group of Text lines that together form a paragraph.
-    It splits content into lines that fit within max_width by measuring rendered width.
-    Each line is a separate Text object joined into a VGroup and arranged downward.
-    """
-    words = content.split()
-    lines = []
-    current = ""
-
-    # Create a temporary Text to measure width; use the same font/size as final lines
-    temp = Text("", color=color, font=font, font_size=font_size)
-
-    for w in words:
-        test = w if not current else current + " " + w
-        test_obj = Text(test, color=color, font=font, font_size=font_size)
-        if test_obj.width <= max_width:
-            current = test
-        else:
-            # flush the current line
-            line = Text(current, color=color, font=font, font_size=font_size)
-            lines.append(line)
-            current = w
-    if current:
-        lines.append(Text(current, color=color, font=font, font_size=font_size))
-
-    if not lines:
-        return VGroup()
-
-    para = VGroup(*lines)
-    # Space lines vertically; arrange them as a column
-    para.arrange(DOWN, buff=line_spacing)
-    if align_left:
-        para = para.align_to(LEFT)
-    return para.strip()
-
-def create_manim_script(problem_data, script_path,audio_path,scale=1):
-    """Generate Manim script from problem data with robust wrapping for title, text, and equations."""
-
-    # Defaults
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(generate_tts_optimized(id, lines, lang))
+        finally:
+            loop.close()
+    except Exception as e:
+        print(f"Error in audio_func: {e}")
+        traceback.print_exc()
+        return None, None
+
+
+def create_manim_script(problem_data, script_path, audio_path, scale=1):
+    """Generate Manim script from problem data with robust wrapping."""
+
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
         "text_color": "WHITE",
         "highlight_color": "YELLOW",
-        "font": "",
+        "font": "CMU Serif",
         "text_size": 36,
         "equation_size": 45,
         "title_size": 48,
-        "wrap_width": 15.5  # in scene width units; adjust to taste
+        "wrap_width": 15.5
     })
 
     slides = problem_data.get("slides", [])
@@ -357,122 +328,115 @@ def create_manim_script(problem_data, script_path,audio_path,scale=1):
         raise ValueError("No slides provided in input data")
 
     slides_repr = repr(slides)
+    audio_path_repr = repr(audio_path)
 
-    # Use a dedicated wrap width in scene units; you can adapt how max_width is computed
     wrap_width = float(settings.get("wrap_width", 15.5))
+    background_color = settings.get("background_color", "#0f0f23")
+    text_color = settings.get("text_color", "WHITE")
+    highlight_color = settings.get("highlight_color", "YELLOW")
+    font = settings.get("font", "CMU Serif")
+    text_size = settings.get("text_size", 36)
+    equation_size = settings.get("equation_size", 45)
+    title_size = settings.get("title_size", 48)
+
+    manim_code = f"""from manim import *
 
-    manim_code = f'''
-from manim import *
-import textwrap
 class GeneratedMathScene(Scene):
     def construct(self):
         # Scene settings
-        self.add_sound({audio_path})
-        self.camera.background_color = "{settings.get('background_color', '#0f0f23')}"
-        default_color = {settings.get('text_color', 'WHITE')}
-        highlight_color = {settings.get('highlight_color', 'YELLOW')}
-        default_font = "{settings.get('font', 'CMU Serif')}"
-        text_size = {settings.get('text_size', 36)}
-        equation_size = {settings.get('equation_size', 45)}
-        title_size = {settings.get('title_size', 48)}
+        self.add_sound({audio_path_repr})
+        self.camera.background_color = "{background_color}"
+        default_color = {text_color}
+        highlight_color = {highlight_color}
+        default_font = "{font}"
+        text_size = {text_size}
+        equation_size = {equation_size}
+        title_size = {title_size}
         wrap_width = {wrap_width}
-        
-        # Helper to wrap text into lines that fit within max width
+
         def make_wrapped_paragraph(content, color, font, font_size, line_spacing=0.2):
             lines = []
             words = content.split()
             current = ""
-        
+
             for w in words:
                 test = w if not current else current + " " + w
                 test_obj = Text(test, color=color, font=font, font_size=font_size)
-        
+
                 if test_obj.width <= wrap_width * 0.9:
                     current = test
                 else:
-                    line_obj = Text(current, color=color, font=font, font_size=font_size)
-                    lines.append(line_obj)
+                    if current:
+                        line_obj = Text(current, color=color, font=font, font_size=font_size)
+                        lines.append(line_obj)
                     current = w
-        
+
             if current:
                 lines.append(Text(current, color=color, font=font, font_size=font_size))
-        
+
             if not lines:
                 return VGroup()
-        
-            # --- FIX: Force every line to align to LEFT like line 1 ---
+
             first_line = lines[0]
             for ln in lines:
                 ln.align_to(first_line, LEFT)
-        
+
             para = VGroup(*lines).arrange(DOWN, aligned_edge=LEFT, buff=line_spacing)
             return para
-        class GeneratedMathSceneInner(Scene):
-            pass
+
         content_group = VGroup()
         current_y = 3.0
         line_spacing = 0.8
         slides = {slides_repr}
-        
-        # Build each slide
+
         for idx, slide in enumerate(slides):
             obj = None
             content = slide.get("content", "")
             animation = slide.get("animation", "write_left")
             scalelen = slide.get("duration", 1.0)
-            duration=scalelen*{scale}
+            duration = scalelen * {scale}
             slide_type = slide.get("type", "text")
-            
+
             if slide_type == "title":
-                # Wrap title text
                 title_text = content
-                # Use paragraph wrapping to keep multi-line titles readable
-                lines = []
                 if title_text:
-                    lines = []
-                    # Reuse make_wrapped_paragraph by simulating a single paragraph
                     lines_group = make_wrapped_paragraph(title_text, highlight_color, default_font, title_size, line_spacing=0.2)
                     obj = lines_group if len(lines_group) > 0 else Text(title_text, color=highlight_color, font=default_font, font_size=title_size)
                 else:
                     obj = Text("", color=highlight_color, font=default_font, font_size=title_size)
+
                 if obj.width > wrap_width:
                     obj.scale_to_fit_width(wrap_width)
-                
+
                 obj.move_to(ORIGIN)
                 self.play(FadeIn(obj), run_time=duration * 0.8)
                 self.wait(duration * 0.3)
                 self.play(FadeOut(obj), run_time=duration * 0.3)
                 continue
-            
+
             elif slide_type == "text":
-                # Use wrapping for normal text
                 obj = make_wrapped_paragraph(content, default_color, default_font, text_size, line_spacing=0.25)
-            
+
             elif slide_type == "equation":
-                # Wrap long equations by splitting content into lines if needed
-                # Heuristic: if content is too wide, create a multi-line TeX using \\ line breaks
                 eq_content = content
-                # Optional: insert line breaks at common math breakpoints if needed
                 test = MathTex(eq_content, color=default_color, font_size=equation_size)
                 if test.width > wrap_width:
-                    # naive wrap: insert line breaks at spaces near the middle
                     parts = eq_content.split(" ")
-                    mid = len(parts)//2
+                    mid = len(parts) // 2
                     line1 = " ".join(parts[:mid])
                     line2 = " ".join(parts[mid:])
-                    wrapped_eq = f"{{line1}} \\\\\\\\ {{line2}}"
+                    wrapped_eq = f"{{{{line1}}}} \\\\ {{{{line2}}}}"
                     obj = MathTex(wrapped_eq, color=default_color, font_size=equation_size)
                 else:
                     obj = MathTex(eq_content, color=default_color, font_size=equation_size)
-                
+
                 if obj.width > wrap_width:
                     obj.scale_to_fit_width(wrap_width)
-            
+
             if obj:
-                # Position and animate
                 obj.to_edge(LEFT, buff=0.3)
-                obj.shift(UP * (current_y - obj.height/2))
-                
+                obj.shift(UP * (current_y - obj.height / 2))
+
                 obj_bottom = obj.get_bottom()[1]
                 if obj_bottom < -3.5:
                     scroll_amount = abs(obj_bottom - (-3.5)) + 0.3
@@ -480,7 +444,7 @@ class GeneratedMathScene(Scene):
                     current_y += scroll_amount
                     obj.shift(UP * scroll_amount)
                     obj.to_edge(LEFT, buff=0.3)
-                
+
                 if animation == "write_left":
                     self.play(Write(obj), run_time=duration)
                 elif animation == "fade_in":
@@ -490,99 +454,113 @@ class GeneratedMathScene(Scene):
                     self.play(obj.animate.set_color(highlight_color), run_time=duration * 0.4)
                 else:
                     self.play(Write(obj), run_time=duration)
-                
+
                 content_group.add(obj)
-                # Decrease y for next item
                 current_y -= (getattr(obj, "height", 0) + line_spacing)
                 self.wait(0.3)
-        
+
         if len(content_group) > 0:
             final_box = SurroundingRectangle(content_group[-1], color=highlight_color, buff=0.2)
             self.play(Create(final_box), run_time=0.8)
             self.wait(1.5)
-    '''
+"""
+
+    try:
+        with open(script_path, 'w', encoding='utf-8') as f:
+            f.write(manim_code)
+        print(f"Generated script at {script_path}")
+    except Exception as e:
+        print(f"Error writing script: {e}")
+        raise
 
-    with open(script_path, 'w', encoding='utf-8') as f:
-        f.write(manim_code)
-    
-    print(f"Generated script preview (first 500 chars):{manim_code[:500]}...")
 
 @app.route("/")
 def home():
     return "Flask Manim Video Generator is Running"
 
+
 @app.route("/generate", methods=["POST"])
 def generate_video():
+    temp_work_dir = None
     try:
         raw_data = request.get_json()
-        raw_body=raw_data.get("jsondata" , '')
-        #print(f"Raw body length: {len(raw_body)}")
-        #print(f"First 200 chars: {raw_body[:200]}")
+        if not raw_data:
+            return jsonify({"error": "No JSON data provided"}), 400
+
+        raw_body = raw_data.get("jsondata", '')
+        if not raw_body:
+            return jsonify({"error": "No jsondata field in request"}), 400
+
         lst = raw_body.split("&&&&")
+        if len(lst) < 2:
+            return jsonify({"error": "Invalid data format, missing &&&&separator"}), 400
+
         cleaned = re.sub(r'(\d)\s*\.\s*(\d)', r'\1.\2', lst[0])
-        nlist = ast.literal_eval(cleaned)
-        datalst=[]
-        total=0
-        scale=1
+
+        try:
+            nlist = ast.literal_eval(cleaned)
+        except Exception as e:
+            return jsonify({"error": f"Failed to parse slide data: {str(e)}"}), 400
+
+        datalst = []
+        total = 0.0
+
         for line in range(len(nlist)):
-          total=total+float(nlist[line][3])
-          datalst.append({
-                            "type": nlist[line][0].strip(),
-                            "content": nlist[line][1].strip(),
-                            "animation": nlist[line][2].strip().replace(" ",""),
-                            "duration": nlist[line][3]
-                        })
-        
-        data={
-    "video_settings": {
-        "background_color": "#0f0f23",
-        "text_color": "WHITE",
-        "highlight_color": "YELLOW",
-        "font": "CMU Serif",
-        "text_size": 36,
-        "equation_size": 42,
-        "title_size": 48
-    },
-    "slides":datalst}
-        #audio generating code here
-        best=lst[1].split("&&&")
-        lines=best[0]
+            try:
+                total += float(nlist[line][3])
+                datalst.append({
+                    "type": nlist[line][0].strip(),
+                    "content": nlist[line][1].strip(),
+                    "animation": nlist[line][2].strip().replace(" ", ""),
+                    "duration": float(nlist[line][3])
+                })
+            except (IndexError, ValueError) as e:
+                return jsonify({"error": f"Invalid slide data at index {line}: {str(e)}"}), 400
+
+        if total <= 0:
+            total = 1.0
+
+        data = {
+            "video_settings": {
+                "background_color": "#0f0f23",
+                "text_color": "WHITE",
+                "highlight_color": "YELLOW",
+                "font": "CMU Serif",
+                "text_size": 36,
+                "equation_size": 42,
+                "title_size": 48
+            },
+            "slides": datalst
+        }
+
+        best = lst[1].split("&&&")
+        lines = best[0]
         try:
-            lang=best[1]
+            lang = best[1] if len(best) > 1 else "English"
         except:
-            print(best)
+            lang = "English"
+
         length, audio_path = audio_func(0, lines, lang)
-        if not length or not audio_path:
-            print("Failed to generate audio.")
-
-        scale=float(length)/total
-        
-        # Now proceed with video generation using 'data'
-        print(json.dumps(data, indent=2))  # For debugging
-        # ✅ Final validation
-        if "slides" not in data or not data["slides"]:
-            return jsonify({"error": "No slides provided in request"}), 400
-        
-        print(f"✅ Parsed {len(data['slides'])} slides successfully.")
-        
-        # Validate input
+
+        if not length or not audio_path or not os.path.exists(audio_path):
+            return jsonify({"error": "Failed to generate audio"}), 500
+
+        scale = float(length) / total if total > 0 else 1.0
+
         if "slides" not in data or not data["slides"]:
             return jsonify({"error": "No slides provided in request"}), 400
-        
+
         print(f"Received request with {len(data['slides'])} slides")
-        
-        # Create unique temporary directory
+
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         temp_work_dir = os.path.join(TEMP_DIR, f"manim_{timestamp}")
         os.makedirs(temp_work_dir, exist_ok=True)
-        
-        # Generate Manim script
+
         script_path = os.path.join(temp_work_dir, "scene.py")
-        create_manim_script(data, script_path,audio_path,scale)
+        create_manim_script(data, script_path, audio_path, scale)
         print(f"Created Manim script at {script_path}")
-        
-        # Render video using subprocess
-        quality = 'l'  # l=low, m=medium, h=high
+
+        quality = 'l'
         render_command = [
             "manim",
             f"-q{quality}",
@@ -591,9 +569,9 @@ def generate_video():
             script_path,
             "GeneratedMathScene"
         ]
-        
+
         print(f"Running command: {' '.join(render_command)}")
-        
+
         result = subprocess.run(
             render_command,
             capture_output=True,
@@ -601,7 +579,7 @@ def generate_video():
             cwd=temp_work_dir,
             timeout=120
         )
-        
+
         if result.returncode != 0:
             error_msg = result.stderr or result.stdout
             print(f"Manim rendering failed: {error_msg}")
@@ -609,13 +587,12 @@ def generate_video():
                 "error": "Manim rendering failed",
                 "details": error_msg
             }), 500
-        
+
         print("Manim rendering completed successfully")
-        
-        # Find generated video
+
         quality_map = {'l': '480p15', 'm': '720p30', 'h': '1080p60'}
         video_quality = quality_map.get(quality, '480p15')
-        
+
         video_path = os.path.join(
             temp_work_dir,
             "videos",
@@ -623,25 +600,24 @@ def generate_video():
             video_quality,
             "GeneratedMathScene.mp4"
         )
-        
+
         if not os.path.exists(video_path):
             print(f"Video not found at expected path: {video_path}")
             return jsonify({
                 "error": "Video file not found after rendering",
                 "expected_path": video_path
             }), 500
-        
+
         print(f"Video found at: {video_path}")
-        
-        # Copy to media directory
+
         output_filename = f"math_video_{timestamp}.mp4"
         output_path = os.path.join(MEDIA_DIR, output_filename)
         shutil.copy(video_path, output_path)
         print(f"Video copied to: {output_path}")
-        
-        # Clean up temp directory
+
         try:
-            shutil.rmtree(temp_work_dir)
+            if temp_work_dir and os.path.exists(temp_work_dir):
+                shutil.rmtree(temp_work_dir)
             print("Cleaned up temp directory")
         except Exception as e:
             print(f"Failed to clean temp dir: {e}")
@@ -652,18 +628,30 @@ def generate_video():
             as_attachment=False,
             download_name=output_filename
         )
-        
+
     except subprocess.TimeoutExpired:
         print("Video rendering timeout")
+        if temp_work_dir and os.path.exists(temp_work_dir):
+            try:
+                shutil.rmtree(temp_work_dir)
+            except:
+                pass
         return jsonify({"error": "Video rendering timeout (120s)"}), 504
+
     except Exception as e:
         print(f"Error: {str(e)}")
         traceback.print_exc()
+        if temp_work_dir and os.path.exists(temp_work_dir):
+            try:
+                shutil.rmtree(temp_work_dir)
+            except:
+                pass
         return jsonify({
             "error": str(e),
             "traceback": traceback.format_exc()
         }), 500
 
+
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=False)
+    app.run(host='0.0.0.0', port=port, debug=False)