Update app.py

app.py

@@ -833,180 +833,180 @@ class EnhancedVideoGenerator:
         return f"{hours:02d}:{minutes:02d}:{secs:02d},{msecs:03d}"
 
    def create_video(self, script: str, style: str, duration: int, output_path: str, selected_images: List[str]) -> str:
-    """Create video with enhanced features and proper error handling"""
-    try:
-        # Initialize progress tracking
-        progress_bar = st.progress(0)
-        status_text = st.empty()
-        
-        # Create output directory if it doesn't exist
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        
-        # Validate inputs and paths
-        if not output_path:
-            raise ValueError("Output path cannot be empty")
-        if not selected_images:
-            raise ValueError("No images selected")
-            
-        # Generate voice-over with progress tracking
-        status_text.text("Creating voice-over...")
-        audio = self.generate_voice_over(script)
-        progress_bar.progress(20)
-        
-        # Process images with effects
-        status_text.text("Processing images with effects...")
-        processed_images = []
-        
-        for img_url in selected_images:
-            try:
-                response = requests.get(img_url, timeout=10)
-                response.raise_for_status()
-                img = Image.open(BytesIO(response.content))
-                img = img.convert('RGB')
-                
-                # Apply image effects based on style
-                if style == "Creative":
-                    # Add creative effects
-                    enhancer = ImageEnhance.Contrast(img)
-                    img = enhancer.enhance(1.2)
-                    enhancer = ImageEnhance.Brightness(img)
-                    img = enhancer.enhance(1.1)
-                elif style == "Professional":
-                    # Add professional effects
-                    enhancer = ImageEnhance.Sharpness(img)
-                    img = enhancer.enhance(1.3)
-                
-                img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
-                processed_images.append(img)
+        """Create video with enhanced features and proper error handling"""
+        try:
+            # Initialize progress tracking
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            # Create output directory if it doesn't exist
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            # Validate inputs and paths
+            if not output_path:
+                raise ValueError("Output path cannot be empty")
+            if not selected_images:
+                raise ValueError("No images selected")
                 
-            except Exception as e:
-                print(f"Error processing image {img_url}: {e}")
-                continue
-        
-        progress_bar.progress(40)
-        
-        # Generate frames with transitions
-        status_text.text("Creating frames with transitions...")
-        frames = []
-        fps = 30
-        total_frames = int(duration * fps)
-        frames_per_image = total_frames // len(processed_images)
-        
-        # Convert images to numpy arrays
-        image_arrays = [np.array(img) for img in processed_images]
-        
-        # Add transition effects
-        frame_count = 0
-        for idx, img_array in enumerate(image_arrays):
-            # Calculate frames for this image
-            if idx == len(image_arrays) - 1:
-                n_frames = total_frames - frame_count
-            else:
-                n_frames = min(frames_per_image, total_frames - frame_count)
-            
-            # Add effects and transitions
-            for frame_idx in range(n_frames):
-                # Apply fade in/out effect
-                alpha = 1.0
-                if frame_idx < 15:  # Fade in
-                    alpha = frame_idx / 15
-                elif frame_idx > n_frames - 15:  # Fade out
-                    alpha = (n_frames - frame_idx) / 15
+            # Generate voice-over with progress tracking
+            status_text.text("Creating voice-over...")
+            audio = self.generate_voice_over(script)
+            progress_bar.progress(20)
+            
+            # Process images with effects
+            status_text.text("Processing images with effects...")
+            processed_images = []
+            
+            for img_url in selected_images:
+                try:
+                    response = requests.get(img_url, timeout=10)
+                    response.raise_for_status()
+                    img = Image.open(BytesIO(response.content))
+                    img = img.convert('RGB')
+                    
+                    # Apply image effects based on style
+                    if style == "Creative":
+                        # Add creative effects
+                        enhancer = ImageEnhance.Contrast(img)
+                        img = enhancer.enhance(1.2)
+                        enhancer = ImageEnhance.Brightness(img)
+                        img = enhancer.enhance(1.1)
+                    elif style == "Professional":
+                        # Add professional effects
+                        enhancer = ImageEnhance.Sharpness(img)
+                        img = enhancer.enhance(1.3)
+                    
+                    img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
+                    processed_images.append(img)
+                    
+                except Exception as e:
+                    print(f"Error processing image {img_url}: {e}")
+                    continue
+            
+            progress_bar.progress(40)
+            
+            # Generate frames with transitions
+            status_text.text("Creating frames with transitions...")
+            frames = []
+            fps = 30
+            total_frames = int(duration * fps)
+            frames_per_image = total_frames // len(processed_images)
+            
+            # Convert images to numpy arrays
+            image_arrays = [np.array(img) for img in processed_images]
+            
+            # Add transition effects
+            frame_count = 0
+            for idx, img_array in enumerate(image_arrays):
+                # Calculate frames for this image
+                if idx == len(image_arrays) - 1:
+                    n_frames = total_frames - frame_count
+                else:
+                    n_frames = min(frames_per_image, total_frames - frame_count)
                 
-                frame = img_array * alpha
-                frames.append(frame.astype(np.uint8))
-                frame_count += 1
+                # Add effects and transitions
+                for frame_idx in range(n_frames):
+                    # Apply fade in/out effect
+                    alpha = 1.0
+                    if frame_idx < 15:  # Fade in
+                        alpha = frame_idx / 15
+                    elif frame_idx > n_frames - 15:  # Fade out
+                        alpha = (n_frames - frame_idx) / 15
+                    
+                    frame = img_array * alpha
+                    frames.append(frame.astype(np.uint8))
+                    frame_count += 1
+                    
+                    # Update progress
+                    progress = int(40 + (frame_count / total_frames * 30))
+                    progress_bar.progress(progress)
                 
-                # Update progress
-                progress = int(40 + (frame_count / total_frames * 30))
-                progress_bar.progress(progress)
-            
-            # Add transition to next image
-            if idx < len(image_arrays) - 1:
-                next_img_array = image_arrays[idx + 1]
-                transition_frames = 15
-                for t in range(transition_frames):
-                    if frame_count < total_frames:
-                        alpha = t / transition_frames
-                        transition_frame = cv2.addWeighted(
-                            img_array, 1 - alpha,
-                            next_img_array, alpha, 0
-                        )
-                        frames.append(transition_frame)
-                        frame_count += 1
-        
-        progress_bar.progress(70)
-        
-        # Create video with frames
-        status_text.text("Compiling video...")
-        clip = ImageSequenceClip(frames, fps=fps)
-        
-        # Add audio with proper synchronization
-        audio_duration = audio.duration
-        video_duration = len(frames) / fps
-        
-        if audio_duration > video_duration:
-            audio = audio.subclip(0, video_duration)
-        elif audio_duration < video_duration:
-            clip = clip.subclip(0, audio_duration)
-        
-        final_clip = clip.set_audio(audio)
-        
-        # Write video with progress caching
-        status_text.text("Saving video...")
-        cache_dir = os.path.join(os.path.dirname(output_path), ".cache")
-        os.makedirs(cache_dir, exist_ok=True)
-        
-        try:
-            final_clip.write_videofile(
-                output_path,
-                fps=fps,
-                codec='libx264',
-                audio_codec='aac',
-                ffmpeg_params=['-pix_fmt', 'yuv420p'],
-                temp_audiofile=os.path.join(cache_dir, "temp-audio.m4a"),
-                verbose=False,
-                logger=None
-            )
-        except Exception as e:
-            # Attempt error recovery
-            status_text.text("Attempting error recovery...")
+                # Add transition to next image
+                if idx < len(image_arrays) - 1:
+                    next_img_array = image_arrays[idx + 1]
+                    transition_frames = 15
+                    for t in range(transition_frames):
+                        if frame_count < total_frames:
+                            alpha = t / transition_frames
+                            transition_frame = cv2.addWeighted(
+                                img_array, 1 - alpha,
+                                next_img_array, alpha, 0
+                            )
+                            frames.append(transition_frame)
+                            frame_count += 1
+            
+            progress_bar.progress(70)
+            
+            # Create video with frames
+            status_text.text("Compiling video...")
+            clip = ImageSequenceClip(frames, fps=fps)
+            
+            # Add audio with proper synchronization
+            audio_duration = audio.duration
+            video_duration = len(frames) / fps
+            
+            if audio_duration > video_duration:
+                audio = audio.subclip(0, video_duration)
+            elif audio_duration < video_duration:
+                clip = clip.subclip(0, audio_duration)
+            
+            final_clip = clip.set_audio(audio)
+            
+            # Write video with progress caching
+            status_text.text("Saving video...")
+            cache_dir = os.path.join(os.path.dirname(output_path), ".cache")
+            os.makedirs(cache_dir, exist_ok=True)
+            
             try:
-                # Try alternative codec settings
                 final_clip.write_videofile(
                     output_path,
                     fps=fps,
                     codec='libx264',
-                    audio_codec='mp3',
+                    audio_codec='aac',
+                    ffmpeg_params=['-pix_fmt', 'yuv420p'],
+                    temp_audiofile=os.path.join(cache_dir, "temp-audio.m4a"),
                     verbose=False,
                     logger=None
                 )
-            except Exception as recovery_e:
-                raise RuntimeError(f"Video creation failed even with recovery attempt: {str(recovery_e)}")
-        
-        progress_bar.progress(100)
-        status_text.text("Video generation complete!")
-        
-        return output_path
-        
-    except Exception as e:
-        error_msg = f"Video creation failed: {str(e)}"
-        print(error_msg)
-        raise RuntimeError(error_msg)
-    finally:
-        # Cleanup
-        try:
-            if 'clip' in locals():
-                clip.close()
-            if 'final_clip' in locals():
-                final_clip.close()
-            if 'audio' in locals():
-                audio.close()
+            except Exception as e:
+                # Attempt error recovery
+                status_text.text("Attempting error recovery...")
+                try:
+                    # Try alternative codec settings
+                    final_clip.write_videofile(
+                        output_path,
+                        fps=fps,
+                        codec='libx264',
+                        audio_codec='mp3',
+                        verbose=False,
+                        logger=None
+                    )
+                except Exception as recovery_e:
+                    raise RuntimeError(f"Video creation failed even with recovery attempt: {str(recovery_e)}")
+            
+            progress_bar.progress(100)
+            status_text.text("Video generation complete!")
+            
+            return output_path
+            
         except Exception as e:
-            print(f"Cleanup error: {e}")
-    
+            error_msg = f"Video creation failed: {str(e)}"
+            print(error_msg)
+            raise RuntimeError(error_msg)
+        finally:
+            # Cleanup
+            try:
+                if 'clip' in locals():
+                    clip.close()
+                if 'final_clip' in locals():
+                    final_clip.close()
+                if 'audio' in locals():
+                    audio.close()
+            except Exception as e:
+                print(f"Cleanup error: {e}")
         
             
+                
     def generate_visual_assets(self, script: str, style: str) -> List[Dict]:
         """Generate relevant visual assets based on script content"""
         try: