Update app.py

app.py

@@ -284,40 +284,47 @@ class EnhancedVideoGenerator:
             self.logger.error(f"Voice-over generation failed: {str(e)}")
             return AudioFileClip(duration=len(script.split()) * 0.3)
 
-    def create_video(
-        self,
-        script: str,
-        style: str,
-        duration: int,
-        output_path: str
-    ) -> str:
-        """Create full video with all enhanced features"""
-        try:
-            # Generate visual assets
-            assets = self.generate_visual_assets(script, style)
-            
-            # Generate voice-over
-            audio = self.generate_voice_over(script)
-            
-            # Create frames with visual assets
-            frames = []
-            fps = 30
-            total_frames = int(duration * fps)
-            
-            with ThreadPoolExecutor() as executor:
-                frame_futures = []
+    def create_video(self, script: str, style: str, duration: int, output_path: str) -> str:
+    """Create full video with all enhanced features"""
+    try:
+        # Progress bar
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        # Generate visual assets (20%)
+        status_text.text("Generating visual assets...")
+        assets = self.generate_visual_assets(script, style)
+        progress_bar.progress(20)
+        
+        # Generate voice-over (40%)
+        status_text.text("Creating voice-over...")
+        audio = self.generate_voice_over(script)
+        progress_bar.progress(40)
+        
+        # Create frames
+        fps = 30
+        total_frames = int(duration * fps)
+        frames = []
+        
+        # Use smaller batch size for better memory management
+        batch_size = 10
+        num_batches = (total_frames + batch_size - 1) // batch_size
+        
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            for batch in range(num_batches):
+                status_text.text(f"Generating frames: {batch*batch_size}/{total_frames}")
+                start_frame = batch * batch_size
+                end_frame = min((batch + 1) * batch_size, total_frames)
                 
-                for i in range(total_frames):
-                    # Calculate current text segment
+                frame_futures = []
+                for i in range(start_frame, end_frame):
                     progress = i / total_frames
                     text_index = int(progress * len(script.split()))
                     current_text = " ".join(script.split()[:text_index + 1])
                     
-                    # Get appropriate background
-                    asset_index = int(progress * len(assets))
+                    asset_index = int(progress * len(assets)) if assets else 0
                     current_asset = assets[asset_index] if assets else None
                     
-                    # Submit frame creation to thread pool
                     future = executor.submit(
                         self.create_enhanced_frame,
                         current_text,
@@ -328,38 +335,58 @@ class EnhancedVideoGenerator:
                     )
                     frame_futures.append(future)
                 
-                # Collect frames
-                frames = [future.result() for future in frame_futures]
-
-            # Create video clip
-            video = ImageSequenceClip(frames, fps=fps)
-            
-            # Add voice-over
-            video = video.set_audio(audio)
-            
-            # Add background music (if available)
-            try:
-                music = AudioFileClip("assets/music/background.mp3")
-                music = music.volumex(0.1).loop(duration=video.duration)
-                video = video.set_audio(CompositeAudioClip([video.audio, music]))
-            except Exception as e:
-                self.logger.warning(f"Background music addition failed: {str(e)}")
-
-            # Write final video
-            video.write_videofile(
-                output_path,
-                fps=fps,
-                codec='libx264',
-                audio_codec='aac',
-                threads=4,
-                preset='medium'
-            )
-
-            return output_path
-
-        except Exception as e:
-            self.logger.error(f"Video creation failed: {str(e)}")
-            raise
+                batch_frames = [future.result() for future in frame_futures]
+                frames.extend(batch_frames)
+                
+                progress = int(60 + (batch/num_batches) * 30)
+                progress_bar.progress(progress)
+
+        # Create video clip (90%)
+        status_text.text("Compiling video...")
+        video = ImageSequenceClip(frames, fps=fps)
+        video = video.set_audio(audio)
+        progress_bar.progress(90)
+        
+        # Write final video (100%)
+        status_text.text("Saving video...")
+        video.write_videofile(
+            output_path,
+            fps=fps,
+            codec='libx264',
+            audio_codec='aac',
+            threads=4,
+            preset='ultrafast'  # Faster encoding
+        )
+        
+        progress_bar.progress(100)
+        status_text.text("Video generation complete!")
+        return output_path
+
+    except Exception as e:
+        self.logger.error(f"Video creation failed: {str(e)}")
+        raise
+
+def generate_visual_assets(self, script: str, style: str) -> List[Dict]:
+    """Generate relevant visual assets based on script content"""
+    try:
+        # Simplified asset generation for faster processing
+        topics = self.extract_key_topics(script)[:3]  # Limit to 3 topics
+        
+        assets = []
+        for topic in topics:
+            # Create simple colored backgrounds instead of AI images
+            img = Image.new('RGB', (1920, 1080), self.themes[style]['bg'])
+            assets.append({
+                'type': 'image',
+                'data': img,
+                'topic': topic
+            })
+
+        return assets
+
+    except Exception as e:
+        self.logger.error(f"Visual asset generation failed: {str(e)}")
+        return []
 
     @staticmethod
     def clean_text(text: str) -> str: