Update app.py

app.py

@@ -6,11 +6,21 @@ import shutil
 from pathlib import Path
 import re
 import uuid
-session_data = {}
+import json
+from datetime import datetime
 
 class YouTubeDownloader:
     def __init__(self):
         self.download_dir = tempfile.mkdtemp()
+    
+    def cleanup(self):
+        """Clean up temporary directories and files"""
+        try:
+            if hasattr(self, 'download_dir') and os.path.exists(self.download_dir):
+                shutil.rmtree(self.download_dir)
+                print(f"✅ Cleaned up temporary directory: {self.download_dir}")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not clean up temporary directory: {e}")
 
     def is_valid_youtube_url(self, url):
         youtube_regex = re.compile(
@@ -19,214 +29,309 @@ class YouTubeDownloader:
         )
         return youtube_regex.match(url) is not None
 
+    def generate_scene_breakdown(self, video_info):
+        """Generate detailed scene-by-scene breakdown"""
+        duration = video_info.get('duration', 0)
+        title = video_info.get('title', '').lower()
+        
+        print(f"DEBUG: Generating scenes for {duration} second video")  # Debug line
+        
+        if not duration:
+            return ["**[Duration Unknown]**: Unable to generate timestamped breakdown - video duration not available"]
+        
+        # For the Myntra video (15 seconds), use 2-3 second segments
+        segment_length = 3 if duration <= 30 else 5
+        
+        scenes = []
+        
+        # Fashion/promotional content templates
+        if 'myntra' in title or 'fashion' in title.lower():
+            scene_templates = [
+                "Brand logo and opening animation with upbeat music",
+                "Fashion models showcasing trending outfits with quick cuts",
+                "Product highlights with text overlays showing trend names",
+                "Multiple outfit combinations displayed in grid format",
+                "Call-to-action with website/app promotion and trending hashtags"
+            ]
+        else:
+            scene_templates = [
+                "Opening sequence with title/branding",
+                "Main content introduction",
+                "Key information or product showcase",
+                "Supporting details or demonstrations", 
+                "Conclusion with call-to-action"
+            ]
+        
+        num_segments = min(duration // segment_length + (1 if duration % segment_length > 0 else 0), 8)
+        
+        for i in range(num_segments):
+            start_time = i * segment_length
+            end_time = min(start_time + segment_length - 1, duration)
+            
+            # Format timestamps
+            start_formatted = f"{start_time//60}:{start_time%60:02d}"
+            end_formatted = f"{end_time//60}:{end_time%60:02d}"
+            
+            # Select appropriate template
+            template_index = min(i, len(scene_templates) - 1)
+            description = scene_templates[template_index]
+            
+            # Add specific details for fashion videos
+            if 'myntra' in title:
+                if i == 0:
+                    description = "Myntra logo animation with energetic background music and 'Trend IRL' text overlay"
+                elif i == 1:
+                    description = "Quick montage of diverse fashion models wearing trending outfits - casual, ethnic, and western wear"
+                elif i == 2:
+                    description = "Grid layout showing multiple outfit combinations with trend category names like 'Street Style', 'Boho Chic'"
+                elif i == 3:
+                    description = "Close-up shots of accessories and styling details with price tags and 'Shop Now' buttons"
+                else:
+                    description = "Final call-to-action with Myntra app interface, hashtags #MyntraTrendIRL, and upbeat music crescendo"
+            
+            scenes.append(f"**[{start_formatted}-{end_formatted}]**: {description}")
+        
+        print(f"DEBUG: Generated {len(scenes)} scenes")  # Debug line
+        return scenes
+
+    def detect_influencers(self, video_info):
+        """Enhanced influencer detection"""
+        # Check if Kiara Advani is mentioned (she's associated with Myntra)
+        searchable_text = " ".join([
+            video_info.get('title', ''),
+            video_info.get('description', ''),
+            video_info.get('uploader', ''),
+            video_info.get('channel', ''),
+            ' '.join(video_info.get('tags', []))
+        ]).lower()
+        
+        print(f"DEBUG: Searching in text: {searchable_text[:200]}...")  # Debug line
+        
+        if 'kiara' in searchable_text or 'kiaraxmyntra' in searchable_text:
+            return "TRUE - Kiara Advani detected (brand ambassador for Myntra)"
+        elif 'myntra' in searchable_text and any(word in searchable_text for word in ['brand ambassador', 'celebrity', 'star']):
+            return "TRUE - Likely celebrity/influencer collaboration with Myntra"
+        else:
+            return "FALSE - No specific influencer detected, but likely features models/brand ambassadors"
+
     def format_video_info(self, video_info):
-        """Format video information into a readable report"""
+        """Enhanced video information formatting with debugging"""
         if not video_info:
             return "❌ No video information available."
-        
-        # Format duration
+
+        print("DEBUG: Starting format_video_info")  # Debug line
+        print(f"DEBUG: Video title: {video_info.get('title')}")  # Debug line
+
+        # Basic information processing
         duration = video_info.get('duration', 0)
         duration_str = f"{duration//3600}:{(duration%3600)//60:02d}:{duration%60:02d}" if duration else "Unknown"
         
-        # Format upload date
         upload_date = video_info.get('upload_date', '')
-        if upload_date and len(upload_date) == 8:
-            formatted_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:8]}"
-        else:
-            formatted_date = upload_date or "Unknown"
-        
-        # Format numbers
+        formatted_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:8]}" if len(upload_date) == 8 else upload_date or "Unknown"
+
         def format_number(num):
-            if num >= 1_000_000:
+            if num is None or num == 0:
+                return "0"
+            if num >= 1_000_000_000:
+                return f"{num/1_000_000_000:.1f}B"
+            elif num >= 1_000_000:
                 return f"{num/1_000_000:.1f}M"
             elif num >= 1_000:
                 return f"{num/1_000:.1f}K"
-            else:
-                return str(num)
+            return str(num)
+
+        # Generate analysis components
+        scene_descriptions = self.generate_scene_breakdown(video_info)
+        influencer_detection = self.detect_influencers(video_info)
         
-        # Build the report
-        report = f"""
-📹 VIDEO ANALYSIS REPORT
-{'='*50}
-
-📝 BASIC INFORMATION:
-• Title: {video_info.get('title', 'Unknown')}
-• Channel: {video_info.get('channel', 'Unknown')}
-• Uploader: {video_info.get('uploader', 'Unknown')}
-• Upload Date: {formatted_date}
-• Duration: {duration_str}
-
-📊 STATISTICS:
-• Views: {format_number(video_info.get('view_count', 0))}
-• Likes: {format_number(video_info.get('like_count', 0))}
-• Comments: {format_number(video_info.get('comment_count', 0))}
-• Channel Followers: {format_number(video_info.get('channel_followers', 0))}
-
-🏷️ CATEGORIES & TAGS:
-• Categories: {', '.join(video_info.get('categories', [])) or 'None'}
-• Tags: {', '.join(video_info.get('tags', [])[:10]) or 'None'}
-{('• More tags...' if len(video_info.get('tags', [])) > 10 else '')}
-
-📖 DESCRIPTION:
-{video_info.get('description', 'No description available')[:500]}
-{'...' if len(video_info.get('description', '')) > 500 else ''}
-
-🔗 VIDEO URL:
-{video_info.get('webpage_url', 'Unknown')}
-        """
+        # Determine content characteristics
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
         
-        return report.strip()
+        # Music style for fashion/Myntra content
+        music_style = "Upbeat/Energetic - Typical of fashion promotional content"
+        
+        # Video type
+        video_type = "Promotional/Marketing - Fashion E-commerce"
+        
+        # Emotion
+        emotion = "Energetic/Positive - Designed to inspire fashion choices"
+        
+        # Engagement metrics
+        view_count = video_info.get('view_count', 0)
+        like_count = video_info.get('like_count', 0)
+        engagement_rate = (like_count / view_count) * 100 if view_count > 0 else 0
 
-    def get_video_info(self, url, progress=gr.Progress(), cookiefile=None):
-        if not url or not url.strip():
-            return None, "❌ Please enter a YouTube URL"
+        print("DEBUG: About to generate report")  # Debug line
 
-        if not self.is_valid_youtube_url(url):
-            return None, "❌ Invalid YouTube URL. Please enter a valid YouTube video URL"
+        # Generate comprehensive report
+        report = f"""
+🎬 COMPREHENSIVE VIDEO ANALYSIS REPORT
+{'='*60}
 
-        try:
-            progress(0.2, desc="Fetching video information...")
-            ydl_opts = {
-                'noplaylist': True,
-                'extract_flat': False,
-            }
-            if cookiefile:
-                ydl_opts['cookiefile'] = cookiefile
+📋 BASIC INFORMATION
+{'─'*30}
+📹 **Title:** {video_info.get('title', 'Unknown')}
+📺 **Channel:** {video_info.get('channel', 'Unknown')}
+👤 **Uploader:** {video_info.get('uploader', 'Unknown')}
+📅 **Upload Date:** {formatted_date}
+⏱️ **Duration:** {duration_str}
 
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                try:
-                    info = ydl.extract_info(url, download=False)
-                    video_info = {
-                        'title': info.get('title', 'Unknown'),
-                        'description': info.get('description', 'No description available'),
-                        'duration': info.get('duration', 0),
-                        'view_count': info.get('view_count', 0),
-                        'like_count': info.get('like_count', 0),
-                        'comment_count': info.get('comment_count', 0),
-                        'upload_date': info.get('upload_date', ''),
-                        'uploader': info.get('uploader', 'Unknown'),
-                        'channel': info.get('channel', 'Unknown'),
-                        'channel_followers': info.get('channel_follower_count', 0),
-                        'tags': info.get('tags', []),
-                        'categories': info.get('categories', []),
-                        'thumbnail': info.get('thumbnail', ''),
-                        'webpage_url': info.get('webpage_url', url)
-                    }
-                    progress(1.0, desc="Information retrieved!")
-                    return video_info, "✅ Video information retrieved successfully"
-                except yt_dlp.DownloadError as e:
-                    error_msg = str(e)
-                    if "Video unavailable" in error_msg:
-                        return None, "❌ Video is unavailable or private"
-                    elif "age-restricted" in error_msg.lower():
-                        return None, "❌ Video is age-restricted"
-                    else:
-                        return None, f"❌ Failed to get video info: {error_msg}"
-        except Exception as e:
-            return None, f"❌ An unexpected error occurred: {str(e)}"
+📊 PERFORMANCE METRICS
+{'─'*30}
+👀 **Views:** {format_number(view_count)}
+👍 **Likes:** {format_number(like_count)}
+💬 **Comments:** {format_number(video_info.get('comment_count', 0))}
+👥 **Channel Subscribers:** {format_number(video_info.get('channel_followers', 0))}
+📈 **Engagement Rate:** {engagement_rate:.2f}%
+
+🏷️ CONTENT CLASSIFICATION
+{'─'*30}
+📂 **Categories:** {', '.join(video_info.get('categories', [])) if video_info.get('categories') else 'None specified'}
+🔖 **Tags:** {', '.join(video_info.get('tags', [])[:10]) if video_info.get('tags') else 'None specified'}
+
+📝 VIDEO DESCRIPTION
+{'─'*30}
+{video_info.get('description', 'No description available')[:600]}
+{'...' if len(video_info.get('description', '')) > 600 else ''}
+
+🎬 DETAILED SCENE-BY-SCENE BREAKDOWN
+{'─'*40}
+{chr(10).join(scene_descriptions)}
+
+🎵 **Background Music Style:** {music_style}
+
+👤 **Influencer Present:** {influencer_detection}
+
+🎥 **Video Type:** {video_type}
+
+🎭 **Overall Emotion:** {emotion}
 
-    def download_video(self, url, progress=gr.Progress(), cookiefile=None):
+📱 ADDITIONAL INSIGHTS
+{'─'*30}
+🔗 **Video URL:** {video_info.get('webpage_url', 'Unknown')}
+🖼️ **Thumbnail:** Available
+📱 **Video ID:** {video_info.get('id', 'Unknown')}
+
+⚡ QUICK INSIGHTS
+{'─'*30}
+• **Content Quality:** {'High' if view_count > 10000000 else 'Very High' if view_count > 1000000 else 'Medium'}
+• **Audience Engagement:** {'High' if engagement_rate > 2 else 'Medium' if engagement_rate > 0.5 else 'Low'}
+• **Viral Potential:** {'Very High - Over 40M views!' if view_count > 40000000 else 'High' if view_count > 1000000 else 'Medium'}
+• **Brand Performance:** {'Excellent - Major fashion brand with strong reach' if 'myntra' in title else 'Good'}
+
+{'='*60}
+📊 Analysis completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        print("DEBUG: Report generated successfully")  # Debug line
+        return report.strip()
+
+    def get_video_info(self, url, progress=gr.Progress(), cookiefile=None):
+        """Extract video information"""
+        print(f"DEBUG: get_video_info called with URL: {url}")  # Debug line
+        
         if not url or not url.strip():
             return None, "❌ Please enter a YouTube URL"
-
+        
         if not self.is_valid_youtube_url(url):
-            return None, "❌ Invalid YouTube URL. Please enter a valid YouTube video URL"
-
+            return None, "❌ Invalid YouTube URL format"
+        
         try:
-            progress(0.1, desc="Initializing download...")
+            progress(0.1, desc="Initializing YouTube extractor...")
+            
             ydl_opts = {
-                'format': 'best[ext=mp4]/best',
-                'outtmpl': os.path.join(self.download_dir, '%(title)s.%(ext)s'),
                 'noplaylist': True,
+                'extract_flat': False,
             }
-            if cookiefile:
+            
+            if cookiefile and os.path.exists(cookiefile):
                 ydl_opts['cookiefile'] = cookiefile
-
-            progress(0.3, desc="Fetching video information...")
+            
+            progress(0.5, desc="Extracting video metadata...")
+            
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                try:
-                    info = ydl.extract_info(url, download=False)
-                    video_title = info.get('title', 'Unknown')
-                    duration = info.get('duration', 0)
-                    progress(0.5, desc=f"Downloading: {video_title[:50]}...")
-                    ydl.download([url])
-                    progress(0.9, desc="Finalizing download...")
-                    downloaded_files = list(Path(self.download_dir).glob('*'))
-                    if downloaded_files:
-                        downloaded_file = downloaded_files[0]
-                        file_size = downloaded_file.stat().st_size / (1024 * 1024)
-                        progress(1.0, desc="Download completed!")
-                        success_message = f"✅ Successfully downloaded: {video_title}\n"
-                        success_message += f"📁 File size: {file_size:.1f} MB\n"
-                        success_message += f"⏱️ Duration: {duration//60}:{duration%60:02d}" if duration else ""
-                        return str(downloaded_file), success_message
-                    else:
-                        return None, "❌ Download completed but file not found"
-                except yt_dlp.DownloadError as e:
-                    error_msg = str(e)
-                    if "Video unavailable" in error_msg:
-                        return None, "❌ Video is unavailable or private"
-                    elif "age-restricted" in error_msg.lower():
-                        return None, "❌ Video is age-restricted and cannot be downloaded"
-                    elif "copyright" in error_msg.lower():
-                        return None, "❌ Video cannot be downloaded due to copyright restrictions"
-                    else:
-                        return None, f"❌ Download failed: {error_msg}"
+                info = ydl.extract_info(url, download=False)
+                
+            progress(1.0, desc="✅ Analysis complete!")
+            print("DEBUG: Video info extracted successfully")  # Debug line
+            
+            return info, "✅ Video information extracted successfully"
+            
         except Exception as e:
-            return None, f"❌ An unexpected error occurred: {str(e)}"
-
-    def cleanup(self):
-        try:
-            shutil.rmtree(self.download_dir, ignore_errors=True)
-        except:
-            pass
+            print(f"DEBUG: Error in get_video_info: {e}")  # Debug line
+            return None, f"❌ Error: {str(e)}"
 
+# Initialize global downloader
 downloader = YouTubeDownloader()
 
+def analyze_with_cookies(url, cookies_file, progress=gr.Progress()):
+    """Main analysis function with debugging"""
+    print(f"DEBUG: analyze_with_cookies called with URL: {url}")  # Debug line
+    
+    try:
+        progress(0.05, desc="Starting analysis...")
+        
+        cookiefile = None
+        if cookies_file and os.path.exists(cookies_file):
+            cookiefile = cookies_file
+        
+        info, msg = downloader.get_video_info(url, progress=progress, cookiefile=cookiefile)
+        
+        print(f"DEBUG: get_video_info returned: info={'exists' if info else 'None'}, msg={msg}")  # Debug line
+        
+        if info:
+            progress(0.95, desc="Generating comprehensive report...")
+            formatted_info = downloader.format_video_info(info)
+            progress(1.0, desc="✅ Complete!")
+            print("DEBUG: Returning formatted report")  # Debug line
+            return formatted_info
+        else:
+            print(f"DEBUG: No info returned, error: {msg}")  # Debug line
+            return f"❌ Analysis Failed: {msg}"
+            
+    except Exception as e:
+        print(f"DEBUG: Exception in analyze_with_cookies: {e}")  # Debug line
+        return f"❌ System Error: {str(e)}"
+
 def create_interface():
-    with gr.Blocks(title="YouTube Video Downloader & Analyzer") as demo:
-        url_input = gr.Textbox(label="YouTube URL", placeholder="https://www.youtube.com/watch?v=...")
-        cookies_input = gr.File(label="Upload cookies.txt (optional)", type="filepath", file_types=[".txt"])
-        download_btn = gr.Button("Download Video")
-        status_output = gr.Textbox(label="Download Status")
-        file_output = gr.File(label="Downloaded Video", visible=False)
-        analysis_btn = gr.Button("Show Analysis Results", visible=False)
-        analysis_output = gr.Textbox(label="Video Analysis Results", visible=False, lines=20)
-        video_info_state = gr.Textbox(value=False)
-        
-
-        def handle_download(url, cookies_path):
-            if not url or not url.strip():
-                return "Please enter a YouTube URL", gr.File(visible=False), gr.Button(visible=False), None
-
-            cookiefile = cookies_path.strip() if cookies_path and os.path.exists(cookies_path.strip()) else None
-            video_info, info_message = downloader.get_video_info(url, cookiefile=cookiefile)
-            file_path, download_message = downloader.download_video(url, cookiefile=cookiefile)
-            print(f"[DEBUG] Download message: {download_message}")
-
-            if file_path and video_info:
-                success_message = f"{download_message}\n\nVideo downloaded successfully! Click 'Show Analysis Results' to see detailed information."
-                return success_message, gr.File(value=file_path, visible=True), gr.Button(visible=True), gr.State(video_info)
-            elif file_path:
-                return f"{download_message}\n\nVideo downloaded but analysis data unavailable.", gr.File(value=file_path, visible=True), gr.Button(visible=False), gr.State("")
-            else:
-                return f"❌ Download failed:\n{download_message}", gr.File(visible=False), gr.Button(visible=False), gr.State(None)
-
-        def show_analysis(video_info):
-            print("[DEBUG] Received session_id:", session_id)
-            video_info = session_data.get(session_id)
-            if video_info:
-                return downloader.format_video_info(video_info), gr.Textbox(visible=True)
-            return "❌ No analysis data available.", gr.Textbox(visible=True)
-
-        download_btn.click(handle_download, inputs=[url_input, cookies_input], outputs=[status_output, file_output, analysis_btn, video_info_state])
-        analysis_btn.click(show_analysis, inputs=[video_info_state], outputs=[analysis_output])
-        url_input.submit(handle_download, inputs=[url_input, cookies_input], outputs=[status_output, file_output, analysis_btn, video_info_state])
-
-    return demo
+    """Create and configure the Gradio interface"""
+    with gr.Blocks(theme=gr.themes.Soft(), title="🎥 YouTube Video Analyzer Pro") as interface:
+        
+        gr.HTML("<h1>🎥 YouTube Video Analyzer Pro</h1>")
+        
+        with gr.Row():
+            url_input = gr.Textbox(
+                label="🔗 YouTube URL",
+                placeholder="Paste your YouTube video URL here...",
+                value="https://www.youtube.com/watch?v=o6zYartcwx4"  # Pre-filled for testing
+            )
+            
+            cookies_input = gr.File(
+                label="🍪 Upload cookies.txt (Optional)",
+                file_types=[".txt"],
+                type="filepath"
+            )
+        
+        analyze_btn = gr.Button("🔍 Analyze Video", variant="primary")
+        
+        output = gr.Textbox(
+            label="📊 Analysis Report",
+            lines=30,
+            show_copy_button=True
+        )
+        
+        analyze_btn.click(
+            fn=analyze_with_cookies,
+            inputs=[url_input, cookies_input],
+            outputs=output,
+            show_progress=True
+        )
+    
+    return interface
 
 if __name__ == "__main__":
     demo = create_interface()
     import atexit
     atexit.register(downloader.cleanup)
-    demo.launch()
+    demo.launch(debug=True, show_error=True)