Update app.py

app.py

@@ -21,43 +21,6 @@ from typing import Optional, List, Dict, Tuple
 from bs4 import BeautifulSoup
 import requests
 from io import BytesIO
-import docx
-import PyPDF2
-import pptx
-import cv2
-from PIL import ImageEnhance
-
-class FileProcessor:
-    @staticmethod
-    def read_txt(file):
-        return file.read().decode('utf-8')
-    
-    @staticmethod
-    def read_pdf(file):
-        pdf_reader = PyPDF2.PdfReader(file)
-        text = ""
-        for page in pdf_reader.pages:
-            text += page.extract_text() + "\n"
-        return text
-    
-    @staticmethod
-    def read_docx(file):
-        doc = docx.Document(file)
-        text = ""
-        for para in doc.paragraphs:
-            text += para.text + "\n"
-        return text
-    
-    @staticmethod
-    def read_pptx(file):
-        prs = pptx.Presentation(file)
-        text = ""
-        for slide in prs.slides:
-            for shape in slide.shapes:
-                if hasattr(shape, "text"):
-                    text += shape.text + "\n"
-        return text
-
 
 class ImageScraper:
     def __init__(self):
@@ -833,28 +796,26 @@ 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"""
+        """Create video with selected images and improved 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")
+            # Validate inputs
             if not selected_images:
-                raise ValueError("No images selected")
-                
-            # Generate voice-over with progress tracking
+                raise ValueError("No images selected. Please select at least one image.")
+            
+            if not script.strip():
+                raise ValueError("Script cannot be empty.")
+            
+            # Generate voice-over
             status_text.text("Creating voice-over...")
-            audio = self.generate_voice_over(script)
+            audio = self.generate_fallback_audio(script)  # Using fallback audio for reliability
             progress_bar.progress(20)
             
-            # Process images with effects
-            status_text.text("Processing images with effects...")
+            # Process images
+            status_text.text("Processing images...")
             processed_images = []
             
             for img_url in selected_images:
@@ -863,30 +824,19 @@ class EnhancedVideoGenerator:
                     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
             
+            if not processed_images:
+                raise ValueError("Failed to process any of the selected images.")
+            
             progress_bar.progress(40)
             
-            # Generate frames with transitions
-            status_text.text("Creating frames with transitions...")
+            # Create frames
+            status_text.text("Generating frames...")
             frames = []
             fps = 30
             total_frames = int(duration * fps)
@@ -895,36 +845,24 @@ class EnhancedVideoGenerator:
             # Convert images to numpy arrays
             image_arrays = [np.array(img) for img in processed_images]
             
-            # Add transition effects
+            # Generate frames with transitions
             frame_count = 0
             for idx, img_array in enumerate(image_arrays):
-                # Calculate frames for this image
+                # Calculate how many frames this image should appear
                 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
-                    
-                    frame = img_array * alpha
-                    frames.append(frame.astype(np.uint8))
+                # Add main frames
+                for _ in range(n_frames):
+                    frames.append(img_array)
                     frame_count += 1
-                    
-                    # Update progress
-                    progress = int(40 + (frame_count / total_frames * 30))
-                    progress_bar.progress(progress)
                 
-                # Add transition to next image
+                # Add transition frames to next image
                 if idx < len(image_arrays) - 1:
                     next_img_array = image_arrays[idx + 1]
-                    transition_frames = 15
+                    transition_frames = 15  # Number of transition frames
                     for t in range(transition_frames):
                         if frame_count < total_frames:
                             alpha = t / transition_frames
@@ -941,7 +879,7 @@ class EnhancedVideoGenerator:
             status_text.text("Compiling video...")
             clip = ImageSequenceClip(frames, fps=fps)
             
-            # Add audio with proper synchronization
+            # Add audio
             audio_duration = audio.duration
             video_duration = len(frames) / fps
             
@@ -952,37 +890,27 @@ class EnhancedVideoGenerator:
             
             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)
+            # Ensure output directory exists
+            output_dir = os.path.dirname(output_path)
+            if output_dir and not os.path.exists(output_dir):
+                os.makedirs(output_dir)
+            
+            progress_bar.progress(90)
             
+            # Write video file
+            status_text.text("Saving video...")
             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"),
+                    ffmpeg_params=['-pix_fmt', 'yuv420p'],  # Ensure compatibility
                     verbose=False,
                     logger=None
                 )
             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)}")
+                raise RuntimeError(f"Failed to write video file: {str(e)}")
             
             progress_bar.progress(100)
             status_text.text("Video generation complete!")
@@ -991,7 +919,7 @@ class EnhancedVideoGenerator:
             
         except Exception as e:
             error_msg = f"Video creation failed: {str(e)}"
-            print(error_msg)
+            print(error_msg)  # For debugging
             raise RuntimeError(error_msg)
         finally:
             # Cleanup
@@ -1004,9 +932,9 @@ class EnhancedVideoGenerator:
                     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:
@@ -1119,7 +1047,7 @@ class EnhancedVideoGenerator:
 # Streamlit UI Class
 class VideoGeneratorUI:
     def __init__(self):
-        self.generator = VideoGenerator()
+        self.generator = EnhancedVideoGenerator()
         self.setup_ui()
 
     def setup_ui(self):
@@ -1248,8 +1176,7 @@ class VideoGeneratorUI:
                                 )
                             except Exception as e:
                                 print(f"Error displaying image: {e}")
-        pass
-        
+    
     def show_video_settings(self, prompt: str, selected_images: List[str]):
         """Show video generation settings and controls"""
         st.subheader("Video Settings")
@@ -1276,29 +1203,19 @@ class VideoGeneratorUI:
                 return
                 
             try:
-                # Generate a unique filename with timestamp
-                timestamp = int(time.time())
-                output_filename = f"vaultgenix_video_{timestamp}.mp4"
-                
-                # Create absolute output path
-                output_path = os.path.abspath(os.path.join(
-                    self.generator.base_dir,
-                    output_filename
-                ))
+                output_dir = "temp_videos"
+                os.makedirs(output_dir, exist_ok=True)
+                output_path = os.path.join(output_dir, f"vaultgenix_video_{int(time.time())}.mp4")
                 
-                # Show progress message
-                progress_message = st.empty()
-                progress_message.text("🎥 Generating your video... This may take a few minutes.")
-                
-                video_path = self.generator.generate_video(
+                video_path = self.generator.create_video(
                     prompt,
-                    selected_images,
+                    style,
                     duration,
-                    output_path
+                    output_path,
+                    selected_images
                 )
                 
                 if os.path.exists(video_path):
-                    progress_message.empty()
                     st.success("✨ Video generated successfully!")
                     
                     # Display video
@@ -1310,7 +1227,7 @@ class VideoGeneratorUI:
                         st.download_button(
                             label="⬇️ Download Video",
                             data=video_bytes,
-                            file_name=output_filename,
+                            file_name=os.path.basename(video_path),
                             mime="video/mp4"
                         )
                 else:
@@ -1320,308 +1237,61 @@ class VideoGeneratorUI:
                 st.error(f"Error generating video: {str(e)}")
                 print(f"Video generation error: {str(e)}")  # For debugging
     
-class VideoGenerator:
-    def __init__(self):
-        # Create base directories
-        self.base_dir = os.path.abspath("generated_videos")
-        self.temp_dir = os.path.abspath(tempfile.mkdtemp())
-        
-        # Ensure directories exist
-        os.makedirs(self.base_dir, exist_ok=True)
-        os.makedirs(self.temp_dir, exist_ok=True)
-        
-        self.setup_resources()
-
-    def setup_resources(self):
-        # Initialize font
-        try:
-            font_options = [
-                "arial.ttf",
-                "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-                "/System/Library/Fonts/Helvetica.ttc"
-            ]
-            for font_path in font_options:
-                try:
-                    self.font = ImageFont.truetype(font_path, 40)
-                    break
-                except OSError:
-                    continue
-            else:
-                self.font = ImageFont.load_default()
-        except Exception as e:
-            print(f"Font loading error: {e}")
-            self.font = ImageFont.load_default()
-
-    def create_video_frame(self, image, text, frame_number, total_frames, size=(1920, 1080)):
-        try:
-            # Resize and pad image to maintain aspect ratio
-            img_aspect = image.size[0] / image.size[1]
-            target_aspect = size[0] / size[1]
+    def generate_video(self, prompt: str, style: str, duration: int, selected_images: List[str]):
+        """Handle video generation with improved error handling"""
+        if not selected_images:
+            st.error("Please select at least one image before generating the video.")
+            return
             
-            if img_aspect > target_aspect:
-                new_height = size[1]
-                new_width = int(new_height * img_aspect)
-            else:
-                new_width = size[0]
-                new_height = int(new_width / img_aspect)
+        with st.spinner("🎥 Generating your video..."):
+            try:
+                # Create temp directory if it doesn't exist
+                temp_dir = Path("temp_videos")
+                temp_dir.mkdir(exist_ok=True)
                 
-            image = image.resize((new_width, new_height), Image.LANCZOS)
-            
-            # Create new background
-            frame = Image.new('RGB', size, (0, 0, 0))
-            
-            # Paste resized image in center
-            paste_x = (size[0] - new_width) // 2
-            paste_y = (size[1] - new_height) // 2
-            frame.paste(image, (paste_x, paste_y))
-            
-            # Add text overlay
-            draw = ImageDraw.Draw(frame)
-            
-            # Text background
-            text = textwrap.fill(text, width=50)
-            text_bbox = draw.textbbox((0, 0), text, font=self.font)
-            text_width = text_bbox[2] - text_bbox[0]
-            text_height = text_bbox[3] - text_bbox[1]
-            
-            text_x = (size[0] - text_width) // 2
-            text_y = size[1] - text_height - 100
-            
-            # Semi-transparent background
-            padding = 20
-            draw.rectangle(
-                [
-                    text_x - padding,
-                    text_y - padding,
-                    text_x + text_width + padding,
-                    text_y + text_height + padding
-                ],
-                fill=(0, 0, 0, 180)
-            )
-            
-            # Draw text
-            draw.text((text_x, text_y), text, fill=(255, 255, 255), font=self.font)
-            
-            # Add progress bar
-            self.draw_progress_bar(draw, frame_number, total_frames, size)
-            
-            return np.array(frame)
-            
-        except Exception as e:
-            print(f"Frame creation error: {e}")
-            return np.zeros((*size, 3), dtype=np.uint8)
-
-    def draw_progress_bar(self, draw, frame_number, total_frames, size):
-        progress = frame_number / total_frames
-        bar_width = int(size[0] * 0.8)
-        bar_height = 6
-        x_offset = (size[0] - bar_width) // 2
-        y_position = size[1] - 40
-        
-        # Background bar
-        draw.rectangle(
-            [x_offset, y_position, x_offset + bar_width, y_position + bar_height],
-            fill=(100, 100, 100, 160)
-        )
-        
-        # Progress bar
-        progress_width = int(bar_width * progress)
-        draw.rectangle(
-            [x_offset, y_position, x_offset + progress_width, y_position + bar_height],
-            fill=(255, 255, 255, 200)
-        )
-
-    def generate_video(self, script: str, images: List[str], duration: int, output_path: str) -> str:
-        if not script or not images:
-            raise ValueError("Script and images are required")
-
-        if not output_path:
-            # Generate default output path if none provided
-            timestamp = int(time.time())
-            output_path = os.path.join(self.base_dir, f"video_{timestamp}.mp4")
-        
-        # Ensure output directory exists
-        os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
-        
-        try:
-            # Process images
-            processed_images = []
-            for img_url in images:
-                try:
-                    response = requests.get(img_url)
-                    img = Image.open(BytesIO(response.content)).convert('RGB')
-                    processed_images.append(img)
-                except Exception as e:
-                    print(f"Image processing error: {e}")
-                    continue
-            
-            if not processed_images:
-                raise ValueError("No valid images to process")
-            
-            # Generate frames
-            fps = 30
-            total_frames = duration * fps
-            frames_per_image = total_frames // len(processed_images)
-            
-            # Split script into sections
-            words = script.split()
-            words_per_image = len(words) // len(processed_images)
-            
-            frames = []
-            frame_count = 0
-            
-            # Generate frames
-            for idx, img in enumerate(processed_images):
-                start_idx = idx * words_per_image
-                end_idx = start_idx + words_per_image if idx < len(processed_images) - 1 else len(words)
-                section_text = ' '.join(words[start_idx:end_idx])
+                # Generate unique output path
+                output_path = str(temp_dir / f"vaultgenix_video_{int(time.time())}.mp4")
                 
-                for frame in range(frames_per_image):
-                    if frame_count < total_frames:
-                        frame_img = self.create_video_frame(
-                            img, 
-                            section_text,
-                            frame_count,
-                            total_frames
-                        )
-                        frames.append(frame_img)
-                        frame_count += 1
-                        
-                # Add transitions
-                if idx < len(processed_images) - 1:
-                    next_img = processed_images[idx + 1]
-                    for t in range(15):
-                        if frame_count < total_frames:
-                            alpha = t / 15
-                            transition_frame = Image.blend(
-                                img,
-                                next_img,
-                                alpha
-                            )
-                            frame_img = self.create_video_frame(
-                                transition_frame,
-                                section_text,
-                                frame_count,
-                                total_frames
-                            )
-                            frames.append(frame_img)
-                            frame_count += 1
-            
-            # Generate audio
-            audio_path = os.path.join(self.temp_dir, "audio.mp3")
-            tts = gTTS(text=script, lang='en')
-            tts.save(audio_path)
-            
-            # Create video
-            clip = ImageSequenceClip(frames, fps=fps)
-            audio_clip = AudioFileClip(audio_path)
-            
-            # Adjust durations
-            if audio_clip.duration < clip.duration:
-                clip = clip.subclip(0, audio_clip.duration)
-            else:
-                audio_clip = audio_clip.subclip(0, clip.duration)
-            
-            final_clip = clip.set_audio(audio_clip)
-            
-            # Write video
-            final_clip.write_videofile(
-                output_path,
-                fps=fps,
-                codec='libx264',
-                audio_codec='aac',
-                ffmpeg_params=['-pix_fmt', 'yuv420p']
-            )
-            
-            return output_path
-            
-        except Exception as e:
-            print(f"Video generation error: {e}")
-            raise
-        finally:
-            # Cleanup
-            try:
-                if 'clip' in locals():
-                    clip.close()
-                if 'final_clip' in locals():
-                    final_clip.close()
-                if 'audio_clip' in locals():
-                    audio_clip.close()
-            except Exception as e:
-                print(f"Cleanup error: {e}")
-
-    def cleanup(self):
-        try:
-            import shutil
-            shutil.rmtree(self.temp_dir)
-        except Exception as e:
-            print(f"Cleanup error: {e}")
-
-def create_ui():
-    ui = VideoGeneratorUI()
-    st.title("VaultGenix Video Generator")
-    st.markdown("Create professional videos for your digital legacy management platform")
-    
-    # File upload section
-    st.subheader("Upload Content")
-    uploaded_file = st.file_uploader(
-        "Upload your content (PDF, DOCX, PPTX, or TXT)",
-        type=['pdf', 'docx', 'pptx', 'txt']
-    )
-    
-    # Text input section
-    script = ""
-    if uploaded_file:
-        try:
-            file_processor = FileProcessor()
-            if uploaded_file.type == "text/plain":
-                script = file_processor.read_txt(uploaded_file)
-            elif uploaded_file.type == "application/pdf":
-                script = file_processor.read_pdf(uploaded_file)
-            elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-                script = file_processor.read_docx(uploaded_file)
-            elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.presentationml.presentation":
-                script = file_processor.read_pptx(uploaded_file)
-        except Exception as e:
-            st.error(f"Error processing file: {str(e)}")
-    
-    script = st.text_area("Enter or edit your video script", value=script, height=200)
-    
-    if st.button("Generate Video") and script:
-        try:
-            # Initialize video generator
-            generator = VideoGenerator()
-            
-            # Get stock images (replace with your image selection logic)
-            images = [
-                "https://images.pexels.com/photos/60504/security-protection-anti-virus-software-60504.jpeg",
-                "https://images.pexels.com/photos/5380642/pexels-photo-5380642.jpeg",
-                "https://images.pexels.com/photos/2582937/pexels-photo-2582937.jpeg"
-            ]
-            
-            # Generate video
-            output_path = "output_video.mp4"
-            with st.spinner("Generating video..."):
-                video_path = generator.generate_video(script, images, 30, output_path)
-            
-            # Display video
-            if os.path.exists(video_path):
-                st.success("Video generated successfully!")
-                with open(video_path, 'rb') as video_file:
+                # Generate video
+                video_path = self.generator.create_video(
+                    prompt,
+                    style,
+                    duration,
+                    output_path,
+                    selected_images
+                )
+                
+                if video_path and os.path.exists(video_path):
+                    st.success("✨ Video generated successfully!")
+                    
+                    # Display video
+                    video_file = open(video_path, 'rb')
                     video_bytes = video_file.read()
                     st.video(video_bytes)
                     
                     # Download button
                     st.download_button(
-                        label="Download Video",
+                        label="⬇️ Download Video",
                         data=video_bytes,
-                        file_name="vaultgenix_video.mp4",
+                        file_name=os.path.basename(video_path),
                         mime="video/mp4"
                     )
-            
-        except Exception as e:
-            st.error(f"Error generating video: {str(e)}")
-            print(f"Error details: {str(e)}")
+                    
+                    video_file.close()
+                else:
+                    st.error("Video generation failed. Please try again.")
+                    
+            except Exception as e:
+                st.error(f"Failed to generate video: {str(e)}")
+                print(f"Video generation error: {str(e)}")
+                
+            finally:
+                # Cleanup temporary files
+                try:
+                    if 'video_file' in locals():
+                        video_file.close()
+                except Exception as e:
+                    print(f"Cleanup error: {e}")
 
 if __name__ == "__main__":
-    create_ui()
+    ui = VideoGeneratorUI()