Update app.py

app.py

@@ -28,9 +28,95 @@ class ImageScraper:
         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'
         }
-        # Add temp_dir attribute
         self.temp_dir = Path(tempfile.mkdtemp())
 
+    def get_pixabay_images(self, query: str) -> List[str]:
+        """Get images from Pixabay API with enhanced error handling"""
+        try:
+            # Clean and encode the query
+            clean_query = query.replace(' ', '+').strip()
+            base_url = "https://pixabay.com/api/"
+            
+            params = {
+                'key': self.PIXABAY_API_KEY,
+                'q': clean_query,
+                'image_type': 'photo',
+                'per_page': 20,
+                'safesearch': True,
+                'lang': 'en'
+            }
+            
+            response = requests.get(base_url, params=params, headers=self.headers)
+            
+            # Debug logging
+            print(f"Pixabay API URL: {response.url}")
+            print(f"Response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                print(f"Total hits: {data.get('totalHits', 0)}")
+                if 'hits' in data and data['hits']:
+                    image_urls = [img['largeImageURL'] for img in data['hits']]
+                    print(f"Found {len(image_urls)} images")
+                    return image_urls
+                else:
+                    print("No images found in response")
+                    return self.get_stock_images()
+            else:
+                print(f"Pixabay API error: Status code {response.status_code}")
+                return self.get_stock_images()
+                
+        except Exception as e:
+            print(f"Exception in get_pixabay_images: {str(e)}")
+            return self.get_stock_images()
+
+    def get_stock_images(self) -> List[str]:
+        """Return preset stock images as fallback"""
+        return [
+            "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",
+            "https://images.pexels.com/photos/7319074/pexels-photo-7319074.jpeg",
+            "https://images.pexels.com/photos/4164418/pexels-photo-4164418.jpeg",
+            "https://images.pexels.com/photos/3861969/pexels-photo-3861969.jpeg",
+            "https://images.pexels.com/photos/5473298/pexels-photo-5473298.jpeg",
+            "https://images.pexels.com/photos/4348401/pexels-photo-4348401.jpeg",
+            "https://images.pexels.com/photos/8386440/pexels-photo-8386440.jpeg",
+            "https://images.pexels.com/photos/5473950/pexels-photo-5473950.jpeg"
+        ]
+
+    def get_images(self, query: str, num_images: int = 15) -> List[str]:
+        """Main method to get images with fallback options"""
+        # First try Pixabay
+        images = self.get_pixabay_images(query)
+        
+        # If no Pixabay images, try with technology-related terms
+        if not images:
+            print("No images found for original query, trying tech terms...")
+            tech_terms = ["digital security", "technology", "cyber security", "data protection"]
+            for term in tech_terms:
+                images.extend(self.get_pixabay_images(term))
+                if images:
+                    break
+        
+        # If still no images, use stock images
+        if not images:
+            print("Using fallback stock images...")
+            images = self.get_stock_images()
+        
+        # Remove duplicates and limit to num_images
+        unique_images = list(dict.fromkeys(images))[:num_images]
+        print(f"Returning {len(unique_images)} images")
+        return unique_images
+
+    def verify_image_url(self, url: str) -> bool:
+        """Verify if an image URL is accessible"""
+        try:
+            response = requests.head(url, timeout=5)
+            return response.status_code == 200
+        except:
+            return False
+
     def generate_fallback_audio(self, script: str) -> AudioFileClip:
         """Generate fallback audio using gTTS"""
         try:
@@ -40,22 +126,9 @@ class ImageScraper:
             return AudioFileClip(str(audio_path))
         except Exception as e:
             print(f"Fallback audio generation failed: {e}")
-            # Create silent audio clip
-            duration = len(script.split()) * 0.3  # Approximate duration based on word count
+            duration = len(script.split()) * 0.3
             return AudioFileClip(duration=duration)
-            
-    def get_pixabay_images(self, query: str) -> List[str]:
-        try:
-            url = f"https://pixabay.com/api/?key={self.PIXABAY_API_KEY}&q={query.replace(' ', '+')}&image_type=photo&per_page=20"
-            response = requests.get(url)
-            if response.status_code == 200:
-                data = response.json()
-                if 'hits' in data:
-                    return [img['largeImageURL'] for img in data['hits']]
-            return []
-        except Exception as e:
-            print(f"Pixabay API error: {e}")
-            return []
+
 
     def get_stock_images(self) -> List[str]:
         """Return preset stock images as fallback"""
@@ -120,14 +193,6 @@ class ImageScraper:
             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):
         try:
@@ -696,70 +761,82 @@ class VideoGeneratorUI:
             prompt = st.text_area("Enter your video script", height=200)
             
             if prompt:
-                st.subheader("Select Images for Your Video")
-                images = self.generator.image_scraper.get_images(prompt)
-                
-                if not images:
-                    st.warning("Loading default technology images...")
-                    images = self.generator.image_scraper.get_stock_images()
-                
-                # Image Selection Grid
-                selected_images = []
-                cols = st.columns(3)
-                for idx, img_url in enumerate(images):
-                    with cols[idx % 3]:
-                        try:
-                            # Replace deprecated use_column_width with use_container_width
-                            st.image(img_url, use_container_width=True)
-                            if st.checkbox(f"Select Image {idx + 1}", key=f"img_{idx}"):
-                                selected_images.append(img_url)
-                        except:
-                            continue
-                
-                # Video Generation Settings
-                if selected_images:
-                    st.subheader("Video Settings")
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        style = st.selectbox(
-                            "Choose style",
-                            options=["Professional", "Creative", "Educational"],
-                            index=0
-                        )
-                    with col2:
-                        duration = st.slider(
-                            "Video duration (seconds)",
-                            min_value=30,
-                            max_value=180,
-                            value=60,
-                            step=30
-                        )
-
-                    if st.button("Generate Video", type="primary"):
-                        with st.spinner("Generating your video..."):
-                            try:
-                                output_path = f"vaultgenix_video_{int(time.time())}.mp4"
-                                video_path = self.generator.create_video(
-                                    prompt,
-                                    style,
-                                    duration,
-                                    output_path,
-                                    selected_images
+                with st.spinner("Fetching images..."):
+                    try:
+                        st.subheader("Select Images for Your Video")
+                        images = self.generator.image_scraper.get_images(prompt)
+                        
+                        if not images:
+                            st.warning("No images found. Loading default technology images...")
+                            images = self.generator.image_scraper.get_stock_images()
+                        
+                        # Image Selection Grid
+                        selected_images = []
+                        cols = st.columns(3)
+                        
+                        for idx, img_url in enumerate(images):
+                            with cols[idx % 3]:
+                                try:
+                                    # Verify image URL before displaying
+                                    if self.generator.image_scraper.verify_image_url(img_url):
+                                        st.image(img_url, use_container_width=True)
+                                        if st.checkbox(f"Select Image {idx + 1}", key=f"img_{idx}"):
+                                            selected_images.append(img_url)
+                                except Exception as e:
+                                    print(f"Error displaying image {idx}: {str(e)}")
+                                    continue
+                        
+                        # Only show video settings if images are available
+                        if selected_images:
+                            st.subheader("Video Settings")
+                            col1, col2 = st.columns(2)
+                            with col1:
+                                style = st.selectbox(
+                                    "Choose style",
+                                    options=["Professional", "Creative", "Educational"],
+                                    index=0
+                                )
+                            with col2:
+                                duration = st.slider(
+                                    "Video duration (seconds)",
+                                    min_value=30,
+                                    max_value=180,
+                                    value=60,
+                                    step=30
                                 )
-                                
-                                if os.path.exists(video_path):
-                                    st.success("✨ Video generated successfully!")
-                                    st.video(video_path)
-                                    
-                                    with open(video_path, 'rb') as video_file:
-                                        st.download_button(
-                                            "⬇️ Download Video",
-                                            video_file.read(),
-                                            file_name=output_path,
-                                            mime="video/mp4"
+
+                            if st.button("Generate Video", type="primary"):
+                                with st.spinner("Generating your video..."):
+                                    try:
+                                        output_path = f"vaultgenix_video_{int(time.time())}.mp4"
+                                        video_path = self.generator.create_video(
+                                            prompt,
+                                            style,
+                                            duration,
+                                            output_path,
+                                            selected_images
                                         )
-                            except Exception as e:
-                                st.error(f"Failed to generate video: {str(e)}")
+                                        
+                                        if os.path.exists(video_path):
+                                            st.success("✨ Video generated successfully!")
+                                            st.video(video_path)
+                                            
+                                            with open(video_path, 'rb') as video_file:
+                                                st.download_button(
+                                                    "⬇️ Download Video",
+                                                    video_file.read(),
+                                                    file_name=output_path,
+                                                    mime="video/mp4"
+                                                )
+                                    except Exception as e:
+                                        st.error(f"Failed to generate video: {str(e)}")
+                                        print(f"Video generation error: {str(e)}")
+                        else:
+                            st.error("No valid images found. Please try a different search term.")
+                    
+                    except Exception as e:
+                        st.error(f"An error occurred: {str(e)}")
+                        print(f"Setup error: {str(e)}")
 
 if __name__ == "__main__":
     ui = VideoGeneratorUI()