Update app.py

app.py

@@ -6,6 +6,7 @@ import shutil
 from pathlib import Path
 import re
 import uuid
+
 session_data = {}
 
 class YouTubeDownloader:
@@ -20,33 +21,90 @@ class YouTubeDownloader:
         return youtube_regex.match(url) is not None
 
     def format_video_info(self, video_info):
-        """Format video information into a readable report"""
         if not video_info:
             return "❌ No video information available."
-        
-        # Format duration
+
         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:
                 return f"{num/1_000_000:.1f}M"
             elif num >= 1_000:
                 return f"{num/1_000:.1f}K"
-            else:
-                return str(num)
-        
-        # Build the report
-        report = f"""
-📹 VIDEO ANALYSIS REPORT
+            return str(num)
+
+        scene_descriptions = []
+        if duration:
+            chunk = 3
+            for start in range(0, duration, chunk):
+                end = min(start + chunk - 1, duration)
+                description = f"Visual segment from {start}s to {end}s. (e.g., close-up, presenter talks, etc.)"
+                scene_descriptions.append(f"* **[{start//60}:{start%60:02d}-{end//60}:{end%60:02d}]**: {description}")
+        else:
+            scene_descriptions.append("* No timestamped breakdown available.")
+
+        tags = ' '.join(video_info.get('tags', [])).lower()
+        title = video_info.get('title', '').lower()
+        description_text = video_info.get('description', '').lower()
+        channel = video_info.get('channel', '').lower()
+
+        if any(word in description_text for word in ['calm music', 'soft', 'soothing']):
+            music_style = "Calm"
+        elif any(word in description_text for word in ['energetic', 'upbeat', 'lively']):
+            music_style = "Upbeat"
+        elif "music" not in description_text:
+            music_style = "No music"
+        else:
+            music_style = "Unknown"
+
+        known_names = [
+            "Kartik Aaryan", "Virat Kohli", "Deepika Padukone", "Alia Bhatt", "Ranveer Singh",
+            "MrBeast", "PewDiePie", "CarryMinati", "Prajakta Koli", "Bhuvan Bam",
+            "Amitabh Bachchan", "Katrina Kaif", "Salman Khan", "Kiara Advani",
+            "Kylie Jenner", "Shahrukh Khan", "Ananya Pandey", "Ashish Chanchlani",
+            "Sundar Pichai", "Elon Musk", "Taylor Swift", "Janhvi Kapoor"
+        ]
+
+        metadata = " ".join([
+            video_info.get('title', ''),
+            video_info.get('description', ''),
+            video_info.get('uploader', ''),
+            video_info.get('channel', ''),
+            ' '.join(video_info.get('tags', []))
+        ]).lower()
+
+        matched = [name for name in known_names if any(part in metadata for part in name.lower().split())]
+
+        if matched:
+            influencer_note = f"Yes, known influencer/celebrity detected: {', '.join(matched)}"
+        else:
+            influencer_note = "No known influencer or celebrity detected."
+
+        if any(word in metadata for word in ["actor", "brand ambassador", "featured", "with", "hosted by"]):
+            influencer_note += " (Someone might be featured — check visually)"
+
+        if "review" in title or "demo" in title or "how to" in title:
+            video_type = "Educational"
+        elif "ad" in title or "promo" in title or "launch" in title:
+            video_type = "Promotional"
+        elif "funny" in title or "challenge" in title:
+            video_type = "Entertainment"
+        else:
+            video_type = "Informational"
+
+        if any(word in description_text for word in ['excited', 'amazing', 'love']):
+            emotion = "Positive"
+        elif any(word in description_text for word in ['calm', 'soothing']):
+            emotion = "Neutral"
+        elif any(word in description_text for word in ['warning', 'serious']):
+            emotion = "Serious"
+        else:
+            emotion = "Neutral"
+
+        report = f"""📹 VIDEO ANALYSIS REPORT
 {'='*50}
 
 📝 BASIC INFORMATION:
@@ -67,166 +125,45 @@ class YouTubeDownloader:
 • Tags: {', '.join(video_info.get('tags', [])[:10]) or 'None'}
 {('• More tags...' if len(video_info.get('tags', [])) > 10 else '')}
 
-📖 DESCRIPTION:
+📖 DESCRIPTION (first 500 chars):
 {video_info.get('description', 'No description available')[:500]}
 {'...' if len(video_info.get('description', '')) > 500 else ''}
 
+🎬 SCENE-BY-SCENE BREAKDOWN:
+{chr(10).join(scene_descriptions)}
+
+🎵 BACKGROUND MUSIC STYLE: {music_style}
+👤 INFLUENCER PRESENT: {influencer_note}
+🎥 VIDEO TYPE: {video_type}
+🎭 OVERALL EMOTION: {emotion}
+
 🔗 VIDEO URL:
 {video_info.get('webpage_url', 'Unknown')}
-        """
-        
+"""
         return report.strip()
 
-    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"
-
-        if not self.is_valid_youtube_url(url):
-            return None, "❌ Invalid YouTube URL. Please enter a valid YouTube video URL"
-
+    def get_video_info(self, url):
+        ydl_opts = {
+            'noplaylist': True,
+            'extract_flat': False,
+        }
         try:
-            progress(0.2, desc="Fetching video information...")
-            ydl_opts = {
-                'noplaylist': True,
-                'extract_flat': False,
-            }
-            if cookiefile:
-                ydl_opts['cookiefile'] = cookiefile
-
             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}"
+                info = ydl.extract_info(url, download=False)
+                return info, "✅ Info retrieved"
         except Exception as e:
-            return None, f"❌ An unexpected error occurred: {str(e)}"
-
-    def download_video(self, url, progress=gr.Progress(), cookiefile=None):
-        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"
-
-        try:
-            progress(0.1, desc="Initializing download...")
-            ydl_opts = {
-                'format': 'best[ext=mp4]/best',
-                'outtmpl': os.path.join(self.download_dir, '%(title)s.%(ext)s'),
-                'noplaylist': True,
-            }
-            if cookiefile:
-                ydl_opts['cookiefile'] = cookiefile
-
-            progress(0.3, desc="Fetching video information...")
-            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}"
-        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"❌ {str(e)}"
 
 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])
-
-    return demo
+def analyze(url):
+    info, msg = downloader.get_video_info(url)
+    if info:
+        return downloader.format_video_info(info)
+    else:
+        return msg
+
+demo = gr.Interface(fn=analyze, inputs=gr.Textbox(label="YouTube URL"), outputs="text", title="YouTube Analyzer with Scene Breakdown")
 
 if __name__ == "__main__":
-    demo = create_interface()
-    import atexit
-    atexit.register(downloader.cleanup)
-    demo.launch()
+    demo.launch()