Update app.py

app.py

@@ -18,17 +18,59 @@ import random
 import logging
 import time
 from typing import Optional, List, Dict, Tuple
+from bs4 import BeautifulSoup
+import requests
+from io import BytesIO
 
-class EnhancedVideoGenerator:
+class ImageScraper:
     def __init__(self):
-        """Initialize the video generator with all required components"""
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+
+    def scrape_pexels(self, query: str) -> List[str]:
+        urls = []
+        try:
+            url = f"https://www.pexels.com/search/{query.replace(' ', '%20')}/"
+            response = requests.get(url, headers=self.headers)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            for img in soup.find_all('img', src=True):
+                if 'photos' in img['src'] and 'pexels.com' in img['src']:
+                    urls.append(img['src'])
+        except Exception as e:
+            print(f"Pexels scraping error: {e}")
+        return urls
+
+    def scrape_unsplash(self, query: str) -> List[str]:
+        urls = []
         try:
-            self.setup_logging()
-            self.setup_device()
-            self.initialize_models()
-            self.setup_workspace()
-            self.load_assets()
-            self.setup_themes()
+            url = f"https://unsplash.com/s/photos/{query.replace(' ', '-')}"
+            response = requests.get(url, headers=self.headers)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            for img in soup.find_all('img', src=True):
+                if 'images.unsplash.com' in img['src']:
+                    urls.append(img['src'])
+        except Exception as e:
+            print(f"Unsplash scraping error: {e}")
+        return urls
+
+    def get_images(self, query: str, num_images: int = 15) -> List[str]:
+        all_urls = []
+        all_urls.extend(self.scrape_pexels(query))
+        all_urls.extend(self.scrape_unsplash(query))
+        
+        # Remove duplicates and limit to num_images
+        return list(set(all_urls))[:num_images]
+
+class EnhancedVideoGenerator:
+    def __init__(self):
+        self.setup_logging()
+        self.setup_device()
+        self.initialize_models()
+        self.setup_workspace()
+        self.load_assets()
+        self.setup_themes()
+        self.image_scraper = ImageScraper()
         except Exception as e:
             logging.error(f"Initialization failed: {str(e)}")
             raise RuntimeError("Failed to initialize video generator")
@@ -284,88 +326,77 @@ 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:
-            # 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
+     def create_video(self, script: str, style: str, duration: int, output_path: str, selected_images: List[str]) -> str:
+            """Create video with selected images"""
+            try:
+                # Progress bar
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # Generate voice-over (20%)
+                status_text.text("Creating voice-over...")
+                audio = self.generate_voice_over(script)
+                progress_bar.progress(20)
             
-            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)
-                    
-                    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])
+                # Process selected images (40%)
+                status_text.text("Processing images...")
+                processed_images = []
+                for img_url in selected_images:
+                    response = requests.get(img_url)
+                    img = Image.open(BytesIO(response.content))
+                    img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
+                    processed_images.append(np.array(img))
+                progress_bar.progress(40)
+                
+                # Create frames with transitions
+                fps = 30
+                total_frames = int(duration * fps)
+                frames = []
+                
+                status_text.text("Generating frames...")
+                frames_per_image = total_frames // len(processed_images)
+                
+                for idx, img in enumerate(processed_images):
+                    for _ in range(frames_per_image):
+                        frames.append(img)
                         
-                        asset_index = int(progress * len(assets)) if assets else 0
-                        current_asset = assets[asset_index] if assets else None
-                        
-                        future = executor.submit(
-                            self.create_enhanced_frame,
-                            current_text,
-                            self.themes[style],
-                            i,
-                            total_frames,
-                            current_asset['data'] if current_asset and current_asset['type'] == 'image' else None
-                        )
-                        frame_futures.append(future)
-                    
-                    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
+                    # Add transition frames
+                    if idx < len(processed_images) - 1:
+                        next_img = processed_images[idx + 1]
+                        for alpha in np.linspace(0, 1, 15):
+                            transition_frame = (1 - alpha) * img + alpha * next_img
+                            frames.append(transition_frame.astype(np.uint8))
+                
+                progress_bar.progress(70)
+                
+                # Create video clip
+                status_text.text("Compiling video...")
+                video = ImageSequenceClip(frames, fps=fps)
+                video = video.set_audio(audio)
+                
+                progress_bar.progress(90)
+                
+                # Write final video
+                status_text.text("Saving video...")
+                video.write_videofile(
+                    output_path,
+                    fps=fps,
+                    codec='libx264',
+                    audio_codec='aac',
+                    threads=4,
+                    preset='ultrafast'
+                )
+                
+                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:
@@ -504,42 +535,59 @@ class VideoGeneratorUI:
 
     def setup_ui(self):
         st.title("Enhanced Video Generator")
-
-        with st.form("video_generator_form"):
-            prompt = st.text_area("Enter your video topic/prompt", height=100)
-            col1, col2 = st.columns(2)
+        
+        # Step 1: Input prompt
+        prompt = st.text_input("Enter your video topic/prompt")
+        
+        if prompt:
+            # Step 2: Image Selection
+            st.subheader("Select Images for Your Video")
+            images = self.generator.image_scraper.get_images(prompt)
             
-            with col1:
-                style = st.selectbox("Choose style", options=list(self.generator.themes.keys()))
-            with col2:
-                duration = st.slider("Video duration (seconds)", 10, 300, 60, 10)
-
-            submit_button = st.form_submit_button("Generate Video")
-
-            if submit_button and prompt:
-                try:
-                    output_path = os.path.join(os.getcwd(), f"generated_video_{int(time.time())}.mp4")
-                    
-                    video_path = self.generator.create_video(prompt, style, duration, output_path)
-                    
-                    if os.path.exists(video_path):
-                        st.success("Video generated successfully!")
+            if not images:
+                st.warning("No images found. Try a different search term.")
+                return
+                
+            selected_images = []
+            cols = st.columns(3)
+            for idx, img_url in enumerate(images):
+                with cols[idx % 3]:
+                    try:
+                        response = requests.get(img_url)
+                        img = Image.open(BytesIO(response.content))
+                        st.image(img, use_column_width=True)
+                        if st.checkbox(f"Select Image {idx + 1}", key=f"img_{idx}"):
+                            selected_images.append(img_url)
+                    except:
+                        continue
+            
+            # Step 3: Video Generation (only show if images are selected)
+            if selected_images:
+                st.subheader("Video Generation Settings")
+                col1, col2 = st.columns(2)
+                with col1:
+                    style = st.selectbox("Choose style", options=list(self.generator.themes.keys()))
+                with col2:
+                    duration = st.slider("Video duration (seconds)", 10, 300, 60, 10)
+
+                if st.button("Generate Video"):
+                    try:
+                        output_path = os.path.join(os.getcwd(), f"generated_video_{int(time.time())}.mp4")
+                        video_path = self.generator.create_video(prompt, style, duration, output_path, selected_images)
                         
-                        with open(video_path, 'rb') as video_file:
-                            st.video(video_file)  # Display video
-                            video_bytes = video_file.read()
+                        if os.path.exists(video_path):
+                            st.success("Video generated successfully!")
+                            st.video(video_path)
                             
-                        st.download_button(
-                            "Download Video",
-                            video_bytes,
-                            file_name=os.path.basename(video_path),
-                            mime="video/mp4"
-                        )
-                    else:
-                        st.error("Video file not found")
-                        
-                except Exception as e:
-                    st.error(f"Failed to generate video: {str(e)}")
+                            with open(video_path, 'rb') as video_file:
+                                st.download_button(
+                                    "Download Video",
+                                    video_file.read(),
+                                    file_name=os.path.basename(video_path),
+                                    mime="video/mp4"
+                                )
+                    except Exception as e:
+                        st.error(f"Failed to generate video: {str(e)}")
 
 if __name__ == "__main__":
     ui = VideoGeneratorUI()