Update app.py

app.py

@@ -29,8 +29,78 @@ def is_valid_url(url):
             return True
     return False
 
+def get_video_info(url):
+    """Get video information without downloading"""
+    try:
+        # Extract video ID for YouTube
+        if 'youtube.com' in url or 'youtu.be' in url:
+            video_id = None
+            if 'youtu.be/' in url:
+                video_id = url.split('youtu.be/')[-1].split('?')[0]
+            elif 'watch?v=' in url:
+                video_id = url.split('watch?v=')[-1].split('&')[0]
+            
+            if video_id:
+                # Use YouTube oEmbed API (no key required, often works better)
+                import requests
+                oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
+                response = requests.get(oembed_url, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                    return {
+                        'title': data.get('title', 'Unknown Video'),
+                        'author': data.get('author_name', 'Unknown Author'),
+                        'thumbnail': data.get('thumbnail_url', ''),
+                    }
+    except Exception as e:
+        print(f"Could not get video info: {e}")
+    
+    return None
+
+def analyze_video_from_url(url, query):
+    """Analyze video based on URL and metadata instead of downloading"""
+    # Get video information
+    video_info = get_video_info(url)
+    
+    # Create context from URL and available info
+    context = f"Video URL: {url}\n"
+    if video_info:
+        context += f"Title: {video_info['title']}\n"
+        context += f"Author: {video_info['author']}\n"
+    
+    # Generate AI response based on URL and context
+    try:
+        model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        
+        prompt = f"""
+        I have a video with the following information:
+        {context}
+        
+        User question: {query}
+        
+        Based on the video URL and available metadata, please provide helpful analysis and insights. 
+        Since I cannot directly access the video content, please:
+        
+        1. Analyze what type of content this might be based on the URL and title
+        2. Provide general guidance about analyzing this type of video
+        3. Suggest what insights could typically be extracted
+        4. Give relevant advice based on the platform (YouTube, Instagram, etc.)
+        
+        Be helpful and informative while acknowledging the limitations of not having direct video access.
+        If this appears to be a specific type of content (tutorial, entertainment, news, etc.), 
+        provide relevant analysis frameworks and questions that would be useful.
+        
+        Be conversational and engaging.
+        """
+        
+        response = model.generate_content(prompt)
+        return response.text
+        
+    except Exception as e:
+        raise gr.Error(f"AI analysis failed: {str(e)}")
+
 def download_video(url, progress=gr.Progress()):
-    """Download video from URL using yt-dlp"""
+    """Download video from URL using yt-dlp with better error handling"""
     if not is_valid_url(url):
         raise gr.Error("Please enter a valid YouTube, Instagram, TikTok, or X video URL")
     
@@ -40,19 +110,20 @@ def download_video(url, progress=gr.Progress()):
     temp_video = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
     temp_video.close()
 
-    # yt-dlp options optimized for HF Spaces
+    # yt-dlp options optimized for HF Spaces with better network handling
     ydl_opts = {
         'outtmpl': temp_video.name,
-        'format': 'best[filesize<100M]/worst[filesize<100M]/best',
+        'format': 'best[filesize<50M]/worst[filesize<50M]/best',  # Smaller files for HF
         'quiet': True,
         'no_warnings': True,
         'nooverwrites': False,
         'user_agent': 'Mozilla/5.0 (compatible; GradioApp/1.0)',
-        'retries': 2,
-        'fragment_retries': 2,
-        'extractor_retries': 2,
-        'socket_timeout': 30,
+        'retries': 1,  # Reduced for HF Spaces
+        'fragment_retries': 1,
+        'extractor_retries': 1,
+        'socket_timeout': 15,  # Shorter timeout
         'nocheckcertificate': True,
+        'prefer_insecure': True,  # Sometimes helps with network issues
     }
 
     progress(0.3, desc="Downloading video...")
@@ -65,7 +136,7 @@ def download_video(url, progress=gr.Progress()):
         if os.path.exists(temp_video.name) and os.path.getsize(temp_video.name) > 0:
             file_size_mb = os.path.getsize(temp_video.name) / (1024 * 1024)
             
-            if file_size_mb > 100:
+            if file_size_mb > 50:  # Smaller limit for HF
                 os.unlink(temp_video.name)
                 raise gr.Error(f"Video too large ({file_size_mb:.1f}MB). Please use a smaller video.")
             
@@ -83,12 +154,20 @@ def download_video(url, progress=gr.Progress()):
                 pass
         
         error_msg = str(e)
-        if "403" in error_msg or "Forbidden" in error_msg:
-            raise gr.Error("Video download was blocked. Try a different video or use a shorter one.")
-        elif "404" in error_msg:
-            raise gr.Error("Video not found. Please check the URL.")
+        
+        # Handle specific network errors common in HF Spaces
+        if "Failed to resolve" in error_msg or "No address associated with hostname" in error_msg:
+            raise gr.Error("🌐 Network connectivity issue. Hugging Face Spaces may have restricted access to this platform. Try a different video or platform.")
+        elif "403" in error_msg or "Forbidden" in error_msg:
+            raise gr.Error("🚫 Video download was blocked by the platform. Try a different video.")
+        elif "404" in error_msg or "not found" in error_msg.lower():
+            raise gr.Error("📹 Video not found. Please check the URL.")
+        elif "timeout" in error_msg.lower():
+            raise gr.Error("⏱️ Download timed out. Try a shorter video.")
         else:
-            raise gr.Error(f"Download failed: {error_msg}")
+            # For network errors, fall back to URL-based analysis
+            print(f"Download failed, falling back to URL analysis: {error_msg}")
+            raise Exception("download_failed")  # Special exception for fallback
 
 def analyze_video_with_ai(video_path, query, progress=gr.Progress()):
     """Analyze video using Google Gemini AI"""
@@ -146,23 +225,41 @@ def analyze_video_with_ai(video_path, query, progress=gr.Progress()):
             pass
 
 def process_video_and_chat(url, query):
-    """Main function to download video and get AI response"""
+    """Main function to download video and get AI response with fallback"""
     if not url.strip():
         raise gr.Error("Please enter a video URL")
     
     if not query.strip():
         raise gr.Error("Please enter a question about the video")
     
-    # Download video
     progress = gr.Progress()
     progress(0.0, desc="Starting...")
     
-    video_path = download_video(url, progress)
-    
-    # Analyze with AI
-    response = analyze_video_with_ai(video_path, query, progress)
-    
-    return response
+    try:
+        # Try to download video first
+        video_path = download_video(url, progress)
+        
+        # Analyze with AI using actual video
+        response = analyze_video_with_ai(video_path, query, progress)
+        
+        return response
+        
+    except Exception as e:
+        # If download fails due to network issues, fall back to URL-based analysis
+        if str(e) == "download_failed" or "Network connectivity" in str(e) or "Failed to resolve" in str(e):
+            progress(0.5, desc="Switching to URL-based analysis...")
+            
+            # Add a notice about the fallback
+            fallback_notice = "🔄 **Note**: Direct video download failed due to network restrictions, so I'm providing analysis based on the video URL and metadata.\n\n"
+            
+            try:
+                response = analyze_video_from_url(url, query)
+                return fallback_notice + response
+            except Exception as fallback_error:
+                raise gr.Error(f"Both video download and URL analysis failed: {str(fallback_error)}")
+        else:
+            # Re-raise the original error if it's not a network issue
+            raise e
 
 # Create Gradio interface
 def create_interface():
@@ -191,6 +288,10 @@ def create_interface():
         <div class="header">
             <h1>🎥 The Plug - AI Video Analyzer</h1>
             <p>Analyze videos from YouTube, Instagram, TikTok, and X with AI</p>
+            <div style="background: #f0f0f0; padding: 10px; border-radius: 8px; margin: 10px 0;">
+                <small><strong>🔄 Smart Fallback:</strong> If video download fails due to network restrictions, 
+                the app will analyze based on video metadata and URL instead.</small>
+            </div>
         </div>
         """)