Update app.py

app.py

@@ -6,11 +6,23 @@ import shutil
 from pathlib import Path
 import re
 import uuid
+import json
+from datetime import datetime
+
 session_data = {}
 
 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 +31,523 @@ class YouTubeDownloader:
         )
         return youtube_regex.match(url) is not None
 
+    def analyze_content_type(self, video_info):
+        """Analyze video content to determine type"""
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
+        tags = ' '.join(video_info.get('tags', [])).lower()
+        
+        content_indicators = {
+            'educational': ['tutorial', 'how to', 'learn', 'guide', 'explained', 'lesson', 'course', 'tips'],
+            'promotional': ['ad', 'promo', 'launch', 'brand', 'sponsored', 'commercial', 'product'],
+            'entertainment': ['funny', 'comedy', 'challenge', 'reaction', 'prank', 'meme', 'fun'],
+            'review': ['review', 'unboxing', 'comparison', 'vs', 'test', 'rating'],
+            'vlog': ['vlog', 'daily', 'routine', 'day in', 'life', 'personal'],
+            'music': ['music', 'song', 'cover', 'remix', 'beats', 'audio'],
+            'news': ['news', 'breaking', 'update', 'report', 'latest', 'current']
+        }
+        
+        metadata = f"{title} {description} {tags}"
+        
+        for category, keywords in content_indicators.items():
+            if any(keyword in metadata for keyword in keywords):
+                return category.title()
+        
+        return "General"
+
+    def analyze_emotion(self, video_info):
+        """Analyze emotional tone of the video"""
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
+        
+        emotion_indicators = {
+            'energetic': ['excited', 'amazing', 'incredible', 'wow', 'awesome', 'fantastic', 'energy'],
+            'positive': ['happy', 'love', 'great', 'good', 'wonderful', 'perfect', 'best'],
+            'calm': ['calm', 'peaceful', 'relaxing', 'soothing', 'gentle', 'quiet'],
+            'serious': ['important', 'serious', 'warning', 'critical', 'urgent', 'breaking'],
+            'inspirational': ['inspire', 'motivate', 'change', 'transform', 'achieve', 'success']
+        }
+        
+        metadata = f"{title} {description}"
+        
+        for emotion, keywords in emotion_indicators.items():
+            if any(keyword in metadata for keyword in keywords):
+                return emotion.title()
+        
+        return "Neutral"
+
+    def analyze_music_style(self, video_info):
+        """Analyze background music style"""
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
+        tags = ' '.join(video_info.get('tags', [])).lower()
+        
+        metadata = f"{title} {description} {tags}"
+        
+        music_styles = {
+            'upbeat': ['upbeat', 'energetic', 'fast', 'dance', 'pop', 'electronic', 'rock'],
+            'calm': ['calm', 'soft', 'soothing', 'ambient', 'peaceful', 'meditation', 'acoustic'],
+            'cinematic': ['cinematic', 'dramatic', 'epic', 'orchestral', 'soundtrack'],
+            'lo-fi': ['lo-fi', 'chill', 'study', 'relaxing beats'],
+            'classical': ['classical', 'piano', 'orchestra', 'symphony']
+        }
+        
+        for style, keywords in music_styles.items():
+            if any(keyword in metadata for keyword in keywords):
+                return style.title()
+        
+        # Check if it's likely a music video
+        if any(word in metadata for word in ['music', 'song', 'audio', 'beats']):
+            return "Music Content"
+        
+        return "Background Music Present" if 'music' in metadata else "Minimal/No Music"
+
+    def detect_influencers(self, video_info):
+        """Enhanced influencer detection"""
+        # Expanded list of known personalities
+        known_personalities = {
+            # Indian Film Industry
+            "Kartik Aaryan": ["kartik aaryan", "kartik", "aaryan"],
+            "Deepika Padukone": ["deepika padukone", "deepika"],
+            "Alia Bhatt": ["alia bhatt", "alia"],
+            "Ranveer Singh": ["ranveer singh", "ranveer"],
+            "Kiara Advani": ["kiara advani", "kiara"],
+            "Janhvi Kapoor": ["janhvi kapoor", "janhvi"],
+            "Ananya Panday": ["ananya panday", "ananya"],
+            "Salman Khan": ["salman khan", "salman"],
+            "Shahrukh Khan": ["shahrukh khan", "srk", "shah rukh"],
+            "Amitabh Bachchan": ["amitabh bachchan", "amitabh", "big b"],
+            "Katrina Kaif": ["katrina kaif", "katrina"],
+            
+            # Sports Personalities
+            "Virat Kohli": ["virat kohli", "virat"],
+            "MS Dhoni": ["ms dhoni", "dhoni"],
+            "Rohit Sharma": ["rohit sharma", "rohit"],
+            
+            # International Celebrities
+            "Taylor Swift": ["taylor swift", "taylor"],
+            "Kylie Jenner": ["kylie jenner", "kylie"],
+            "Elon Musk": ["elon musk", "elon"],
+            
+            # YouTubers/Content Creators
+            "MrBeast": ["mrbeast", "mr beast"],
+            "PewDiePie": ["pewdiepie", "felix"],
+            "CarryMinati": ["carryminati", "carry", "ajey nagar"],
+            "Ashish Chanchlani": ["ashish chanchlani", "ashish"],
+            "Bhuvan Bam": ["bhuvan bam", "bb ki vines"],
+            "Prajakta Koli": ["prajakta koli", "mostlysane"],
+            
+            # Tech Personalities
+            "Sundar Pichai": ["sundar pichai", "sundar"],
+            
+            # Beauty/Fashion Influencers
+            "James Charles": ["james charles"],
+            "Nikkie Tutorials": ["nikkie tutorials", "nikkietutorials"]
+        }
+        
+        # Combine all searchable text
+        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()
+        
+        detected_personalities = []
+        
+        for personality, aliases in known_personalities.items():
+            if any(alias in searchable_text for alias in aliases):
+                detected_personalities.append(personality)
+        
+        # Additional indicators
+        influencer_indicators = [
+            "influencer", "creator", "brand ambassador", "celebrity", "star",
+            "featured", "guest", "interview", "collaboration", "collab"
+        ]
+        
+        has_influencer_indicators = any(indicator in searchable_text for indicator in influencer_indicators)
+        
+        if detected_personalities:
+            return f"TRUE - Detected: {', '.join(detected_personalities)}"
+        elif has_influencer_indicators:
+            return "TRUE - Likely influencer/celebrity present (check video for confirmation)"
+        else:
+            return "FALSE - No known personalities detected"
+
+    def generate_scene_breakdown(self, video_info):
+        """Generate enhanced scene-by-scene breakdown"""
+        duration = video_info.get('duration', 0)
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
+        
+        if not duration:
+            return ["**[Duration Unknown]**: Unable to generate timestamped breakdown - video duration not available"]
+        
+        # Determine segment length based on video duration
+        if duration <= 30:
+            segment_length = 2  # 2-second segments for very short videos
+        elif duration <= 60:
+            segment_length = 5  # 5-second segments for short videos
+        elif duration <= 300:  # 5 minutes
+            segment_length = 10  # 10-second segments
+        elif duration <= 900:  # 15 minutes
+            segment_length = 15  # 15-second segments
+        else:
+            segment_length = 30  # 30-second segments for long videos
+        
+        scenes = []
+        
+        # Generate contextual scene descriptions based on video type
+        video_type = self.analyze_content_type(video_info).lower()
+        
+        # Scene templates based on video type
+        scene_templates = {
+            'educational': [
+                "Introduction and topic overview",
+                "Main content explanation with examples",
+                "Detailed demonstration or walkthrough",
+                "Key points summary and tips",
+                "Conclusion and call-to-action"
+            ],
+            'promotional': [
+                "Brand/product introduction",
+                "Key features showcase",
+                "Benefits and advantages highlight",
+                "Social proof or testimonials",
+                "Call-to-action and closing"
+            ],
+            'entertainment': [
+                "Opening hook and introduction",
+                "Main entertainment content",
+                "Peak moment or climax",
+                "Reaction or commentary",
+                "Closing and engagement request"
+            ],
+            'review': [
+                "Product/service introduction",
+                "First impressions and unboxing",
+                "Detailed feature analysis",
+                "Pros and cons discussion",
+                "Final verdict and recommendation"
+            ],
+            'vlog': [
+                "Daily routine introduction",
+                "Activity or event coverage",
+                "Personal commentary and thoughts",
+                "Interaction with others",
+                "Day wrap-up and reflection"
+            ]
+        }
+        
+        templates = scene_templates.get(video_type, [
+            "Opening sequence",
+            "Main content delivery",
+            "Supporting information",
+            "Engagement moment",
+            "Conclusion"
+        ])
+        
+        segment_count = min(duration // segment_length + 1, len(templates) * 2)
+        
+        for i in range(segment_count):
+            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(templates) - 1)
+            base_description = templates[template_index]
+            
+            # Add contextual details
+            if i == 0:
+                description = f"{base_description} - Video begins with title card/intro"
+            elif i == segment_count - 1:
+                description = f"{base_description} - Video concludes with end screen/outro"
+            else:
+                description = f"{base_description} - Continued content delivery"
+            
+            # Add visual and audio cues
+            if 'music' in title or 'song' in title:
+                description += " [Music/audio content]"
+            elif 'tutorial' in title or 'how to' in title:
+                description += " [Instructional content with visual demonstrations]"
+            
+            scenes.append(f"**[{start_formatted}-{end_formatted}]**: {description}")
+        
+        return scenes
+
     def format_video_info(self, video_info):
-        """Format video information into a readable report"""
+        """Enhanced video information formatting"""
         if not video_info:
             return "❌ No video information available."
-        
-        # Format duration
+
+        # 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)
+
+        # Enhanced analysis
+        scene_descriptions = self.generate_scene_breakdown(video_info)
+        music_style = self.analyze_music_style(video_info)
+        influencer_detection = self.detect_influencers(video_info)
+        video_type = self.analyze_content_type(video_info)
+        emotion = self.analyze_emotion(video_info)
+
+        # Additional metadata
+        thumbnail_url = video_info.get('thumbnail', '')
+        language = video_info.get('language', 'Unknown')
+        availability = video_info.get('availability', 'public')
         
-        # 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')}
-        """
+        # Categories and tags processing
+        categories = video_info.get('categories', [])
+        tags = video_info.get('tags', [])
         
-        return report.strip()
+        # Engagement metrics
+        view_count = video_info.get('view_count', 0)
+        like_count = video_info.get('like_count', 0)
+        comment_count = video_info.get('comment_count', 0)
+        
+        engagement_rate = 0
+        if view_count > 0 and like_count is not None:
+            engagement_rate = (like_count / view_count) * 100
 
-    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"
+        # Generate comprehensive report
+        report = f"""
+🎬 COMPREHENSIVE VIDEO ANALYSIS REPORT
+{'='*60}
 
-        if not self.is_valid_youtube_url(url):
-            return None, "❌ Invalid YouTube URL. Please enter a valid YouTube video URL"
+📋 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}
+🌐 **Language:** {language}
+🔓 **Availability:** {availability.title()}
 
-        try:
-            progress(0.2, desc="Fetching video information...")
-            ydl_opts = {
-                'noplaylist': True,
-                'extract_flat': False,
-            }
-            if cookiefile:
-                ydl_opts['cookiefile'] = cookiefile
+📊 PERFORMANCE METRICS
+{'─'*30}
+👀 **Views:** {format_number(view_count)}
+👍 **Likes:** {format_number(like_count)}
+💬 **Comments:** {format_number(comment_count)}
+👥 **Channel Subscribers:** {format_number(video_info.get('channel_followers', 0))}
+📈 **Engagement Rate:** {engagement_rate:.2f}%
 
-            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)}"
+🏷️ CONTENT CLASSIFICATION
+{'─'*30}
+📂 **Categories:** {', '.join(categories) if categories else 'None specified'}
+🔖 **Primary Tags:** {', '.join(tags[:8]) if tags else 'None specified'}
+{('🔖 **Additional Tags:** ' + ', '.join(tags[8:16]) + ('...' if len(tags) > 16 else '')) if len(tags) > 8 else ''}
+
+📝 VIDEO DESCRIPTION
+{'─'*30}
+{video_info.get('description', 'No description available')[:800]}
+{'...\n[Description truncated - Full description available in original video]' if len(video_info.get('description', '')) > 800 else ''}
 
-    def download_video(self, url, progress=gr.Progress(), cookiefile=None):
+🎬 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}
+
+📱 TECHNICAL DETAILS
+{'─'*30}
+🔗 **Video URL:** {video_info.get('webpage_url', 'Unknown')}
+🖼️ **Thumbnail:** {thumbnail_url if thumbnail_url else 'Not available'}
+📱 **Video ID:** {video_info.get('id', 'Unknown')}
+
+⚡ QUICK INSIGHTS
+{'─'*30}
+• **Content Quality:** {'High' if view_count > 100000 else 'Medium' if view_count > 10000 else 'Growing'}
+• **Audience Engagement:** {'High' if engagement_rate > 5 else 'Medium' if engagement_rate > 1 else 'Low'}
+• **Viral Potential:** {'High' if view_count > 1000000 and engagement_rate > 3 else 'Medium' if view_count > 100000 else 'Standard'}
+• **Content Freshness:** {'Recent' if upload_date and upload_date >= '20240101' else 'Older Content'}
+
+{'='*60}
+📊 Analysis completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        return report.strip()
+
+    def get_video_info(self, url, progress=gr.Progress(), cookiefile=None):
+        """Extract video information with enhanced error handling"""
         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,
+                'writesubtitles': False,
+                'writeautomaticsub': False,
+                'ignoreerrors': True,
             }
-            if cookiefile:
+            
+            if cookiefile and os.path.exists(cookiefile):
                 ydl_opts['cookiefile'] = cookiefile
-
-            progress(0.3, desc="Fetching video information...")
+                progress(0.3, desc="Loading cookies for authentication...")
+            
+            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(0.9, desc="Processing video information...")
+            progress(1.0, desc="✅ Analysis complete!")
+            
+            return info, "✅ Video information extracted successfully"
+            
+        except yt_dlp.DownloadError as e:
+            return None, f"❌ YouTube Download Error: {str(e)}"
         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
+            return None, f"❌ Unexpected Error: {str(e)}"
 
+# Initialize global downloader
 downloader = YouTubeDownloader()
 
-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])
+def analyze_with_cookies(url, cookies_file, progress=gr.Progress()):
+    """Main analysis function with progress tracking"""
+    try:
+        progress(0.05, desc="Starting analysis...")
+        
+        cookiefile = None
+        if cookies_file and os.path.exists(cookies_file):
+            cookiefile = cookies_file
+            progress(0.1, desc="Cookies file loaded successfully")
+        
+        info, msg = downloader.get_video_info(url, progress=progress, cookiefile=cookiefile)
+        
+        if info:
+            progress(0.95, desc="Generating comprehensive report...")
+            formatted_info = downloader.format_video_info(info)
+            progress(1.0, desc="✅ Complete!")
+            return formatted_info
+        else:
+            return f"❌ Analysis Failed: {msg}"
+            
+    except Exception as e:
+        return f"❌ System Error: {str(e)}"
 
-    return demo
+def create_interface():
+    """Create and configure the Gradio interface"""
+    with gr.Blocks(
+        theme=gr.themes.Soft(),
+        title="🎥 YouTube Video Analyzer Pro",
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        .main-header {
+            text-align: center;
+            background: linear-gradient(90deg, #ff6b6b, #4ecdc4);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            font-size: 2.5em;
+            font-weight: bold;
+            margin-bottom: 20px;
+        }
+        .description-text {
+            text-align: center;
+            font-size: 1.1em;
+            color: #666;
+            margin-bottom: 30px;
+        }
+        """
+    ) as interface:
+        
+        gr.HTML("""
+        <div class="main-header">
+            🎥 YouTube Video Analyzer Pro
+        </div>
+        <div class="description-text">
+            Get comprehensive analysis of any YouTube video with detailed scene breakdowns, 
+            influencer detection, emotion analysis, and performance metrics. 
+            Upload cookies.txt to access age-restricted or private videos.
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                url_input = gr.Textbox(
+                    label="🔗 YouTube URL",
+                    placeholder="Paste your YouTube video URL here...",
+                    lines=1
+                )
+                
+            with gr.Column(scale=1):
+                cookies_input = gr.File(
+                    label="🍪 Upload cookies.txt (Optional)",
+                    file_types=[".txt"],
+                    type="filepath"
+                )
+        
+        analyze_btn = gr.Button(
+            "🔍 Analyze Video",
+            variant="primary",
+            size="lg"
+        )
+        
+        output = gr.Textbox(
+            label="📊 Comprehensive Analysis Report",
+            lines=35,
+            max_lines=50,
+            show_copy_button=True
+        )
+        
+        analyze_btn.click(
+            fn=analyze_with_cookies,
+            inputs=[url_input, cookies_input],
+            outputs=output,
+            show_progress=True
+        )
+        
+        # Add examples
+        gr.Examples(
+            examples=[
+                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
+                ["https://youtu.be/jNQXAC9IVRw"],
+            ],
+            inputs=url_input,
+            label="🎯 Try these examples:"
+        )
+    
+    return interface
 
 if __name__ == "__main__":
     demo = create_interface()
     import atexit
     atexit.register(downloader.cleanup)
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )