Update app.py

app.py

@@ -1,1167 +1,340 @@
-def format_scene_breakdown(scenes):
-    rows = """
-    <table style='width:100%; border-collapse: collapse; background-color:#1a1a1a; color: #FFFFFF; border: 2px solid #FF8C00; font-size: 16px;box-shadow: 0 4px 8px rgba(0,0,0,0.3);'>
-        <tr style='background-color:#FF8C00; color: #000000;'>
-            <th style='padding: 8px; border: 1px solid  #FF8C00; color: #000000; font-weight: bold;'>⏱️ Timestamp</th>
-            <th style='padding: 8px; border: 1px solid # #FF8C00; color: #000000; font-weight: bold;'>📝 Description</th>
-        </tr>
-    """
-    pattern = re.compile(r"\*\*\[(.*?)\]\*\*:\s*(.*)")
-
-    
-    for scene in scenes:
-        match = pattern.match(scene)
-        if match:
-            timestamp = match.group(1).strip()
-            description = match.group(2).strip()
-            rows += f"""
-             <tr style='background-color:#1a1a1a;'>
-                <td style='padding: 8px; border: 1px solid #444; color: #87CEEB; font-weight: bold;font-size: 16px;vertical-align: top;'>{timestamp}</td>
-                <td style='padding: 8px; border: 1px solid #444; color: #87CEEB; font-weight: bold;font-size: 16px;line-height: 1.4;'>{description}</td>
-            </tr>
-             """
-                
-    rows += "</table>"
-    return rows
-
-
-import gradio as gr
-import yt_dlp
 import os
 import tempfile
-import shutil
-from pathlib import Path
+import gradio as gr
 import re
-import uuid
-import json
-from datetime import datetime
-import google.generativeai as genai
-from xhtml2pdf import pisa
-from io import BytesIO
-
+import sys
+import shutil
 
-def generate_pdf_from_html(html_content):
-    """Generate PDF with simplified HTML that works better with xhtml2pdf"""
+# Try to import required packages with error handling
+try:
+    from yt_dlp import YoutubeDL
+    YT_DLP_AVAILABLE = True
+except ImportError as e:
+    YT_DLP_AVAILABLE = False
+    print(f"yt-dlp import error: {e}")
+
+try:
+    import whisper
+    WHISPER_AVAILABLE = True
+except ImportError as e:
+    WHISPER_AVAILABLE = False
+    print(f"whisper import error: {e}")
+
+print(f"Python version: {sys.version}")
+print(f"yt-dlp available: {YT_DLP_AVAILABLE}")
+print(f"whisper available: {WHISPER_AVAILABLE}")
+
+def download_audio(url, cookies_file_path=None):
+    """Download audio from YouTube URL and return the file path"""
+    if not YT_DLP_AVAILABLE:
+        raise Exception("yt-dlp is not available. Please check the installation.")
+    
     try:
-        # Create a simplified version of the HTML for PDF generation
-        # Remove complex CSS that xhtml2pdf can't handle
-        simplified_html = html_content.replace(
-            "background: linear-gradient(135deg, #2d3748, #1a202c);", 
-            "background-color: #f5f5f5;"
-        ).replace(
-            "background: linear-gradient(90deg, #FF8C00, #87CEEB);", 
-            "background-color: #FF8C00;"
-        ).replace(
-            "rgba(135, 206, 235, 0.1)", 
-            "#f9f9f9"
-        ).replace(
-            "rgba(0, 0, 0, 0.3)", 
-            "#ffffff"
-        ).replace(
-            "text-shadow: 2px 2px 4px rgba(0,0,0,0.5);", 
-            ""
-        ).replace(
-            "box-shadow: 0 8px 32px rgba(255, 140, 0, 0.3);", 
-            ""
-        ).replace(
-            "box-shadow: 0 4px 8px rgba(0,0,0,0.3);", 
-            ""
-        ).replace(
-            "display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px;", 
-            "display: block;"
-        ).replace(
-            "background-color:#1a1a1a;", 
-            "background-color:#ffffff;"
-        ).replace(
-            "color: #FFFFFF;", 
-            "color: #000000;"
-        ).replace(
-            "background-color:#FF8C00; color: #000000;", 
-            "background-color:#FF8C00; color: #000000;"
-        ).replace(
-            "color: #87CEEB;", 
-            "color: #000080;"
-        ).replace(
-            "border: 2px solid #FF8C00;", 
-            "border: 1px solid #FF8C00;"
-        )
-        
-        # Remove table styling that causes issues
-        simplified_html = re.sub(r"style='[^']*background-color:#1a1a1a[^']*'", "style='background-color:#ffffff;'", simplified_html)
-        simplified_html = re.sub(r"style='[^']*color: #87CEEB[^']*'", "style='color: #000080; padding: 8px;'", simplified_html)
-        
-        # Wrap in a complete HTML document with PDF-friendly CSS
-        pdf_html = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <meta charset="UTF-8">
-            <style>
-                @page {{
-                    size: A4;
-                    margin: 1cm;
-                }}
-                body {{ 
-                    font-family: Arial, sans-serif; 
-                    font-size: 12px;
-                    line-height: 1.4;
-                    color: #000000;
-                    background-color: #ffffff;
-                }}
-                .report-container {{
-                    background-color: #ffffff;
-                    padding: 15px;
-                    border: 2px solid #FF8C00;
-                    border-radius: 8px;
-                }}
-                .header {{
-                    text-align: center;
-                    color: #FF8C00;
-                    font-size: 20px;
-                    font-weight: bold;
-                    margin-bottom: 15px;
-                    border-bottom: 2px solid #FF8C00;
-                    padding-bottom: 8px;
-                }}
-                .info-card {{
-                    background-color: #f9f9f9;
-                    padding: 12px;
-                    margin: 8px 0;
-                    border-left: 3px solid #87CEEB;
-                    border-radius: 4px;
-                    page-break-inside: avoid;
-                }}
-                .info-title {{
-                    color: #000080;
-                    font-size: 14px;
-                    font-weight: bold;
-                    margin-bottom: 8px;
-                }}
-                table {{
-                    width: 100%;
-                    border-collapse: collapse;
-                    margin: 8px 0;
-                    page-break-inside: avoid;
-                }}
-                th, td {{
-                    padding: 6px 8px;
-                    border: 1px solid #cccccc;
-                    text-align: left;
-                    vertical-align: top;
-                    font-size: 11px;
-                }}
-                th {{
-                    background-color: #FF8C00;
-                    color: #000000;
-                    font-weight: bold;
-                }}
-                tr:nth-child(even) {{
-                    background-color: #f9f9f9;
-                }}
-                .scene-table {{
-                    margin-top: 15px;
-                }}
-                .scene-header {{
-                    color: #000080;
-                    font-size: 16px;
-                    font-weight: bold;
-                    text-align: center;
-                    margin-bottom: 10px;
-                }}
-                div[style*="display: grid"] {{
-                    display: block !important;
-                }}
-                div[style*="grid-template-columns"] > div {{
-                    display: block !important;
-                    margin-bottom: 10px !important;
-                    width: 100% !important;
-                }}
-            </style>
-        </head>
-        <body>
-            <div class="report-container">
-                {simplified_html}
-            </div>
-        </body>
-        </html>
-        """
+        # Create a temporary directory for downloads
+        temp_dir = tempfile.mkdtemp()
+        output_path = os.path.join(temp_dir, "audio")
+        
+        ydl_opts = {
+            'format': 'bestaudio[ext=m4a]/bestaudio/best',
+            'outtmpl': output_path + '.%(ext)s',
+            'quiet': True,
+            'no_warnings': True,
+        }
         
-        result = BytesIO()
-        pisa_status = pisa.CreatePDF(pdf_html, dest=result)
-        print("PDF buffer length:", len(result.getvalue()))
+        # Add cookies file if provided
+        if cookies_file_path and os.path.exists(cookies_file_path):
+            ydl_opts['cookiefile'] = cookies_file_path
+            print(f"Using cookies file: {cookies_file_path}")
         
-        if pisa_status.err:
-            print(f"PDF generation error: {pisa_status.err}")
-            return None
+        with YoutubeDL(ydl_opts) as ydl:
+            info_dict = ydl.extract_info(url, download=True)
+            filename = ydl.prepare_filename(info_dict)
             
-        result.seek(0)
-        return result
-        
-    except Exception as e:
-        print(f"PDF generation exception: {e}")
-        return None
-
-class YouTubeDownloader:
-    def __init__(self):
-        self.download_dir = tempfile.mkdtemp()
-        # Use temp directory for Gradio compatibility
-        self.temp_downloads = tempfile.mkdtemp(prefix="youtube_downloads_")
-        # Also create user downloads folder for copying
-        self.downloads_folder = os.path.join(os.path.expanduser("~"), "Downloads", "YouTube_Downloads")
-        os.makedirs(self.downloads_folder, exist_ok=True)
-        self.gemini_model = None
-    
-    def configure_gemini(self, api_key):
-        """Configure Gemini API with the provided key"""
-        try:
-            genai.configure(api_key=api_key)
-            self.gemini_model = genai.GenerativeModel(model_name="gemini-1.5-flash-latest")
-            return True, "✅ Gemini API configured successfully!"
-        except Exception as e:
-            return False, f"❌ Failed to configure Gemini API: {str(e)}"
-    
-    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}")
-            if hasattr(self, 'temp_downloads') and os.path.exists(self.temp_downloads):
-                shutil.rmtree(self.temp_downloads)
-                print(f"✅ Cleaned up temp downloads directory: {self.temp_downloads}")
-        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(
-            r'(https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/'
-            r'(watch\?v=|embed/|v/|.+\?v=)?([^&=%\?]{11})'
-        )
-        return youtube_regex.match(url) is not None
-
-    def generate_scene_breakdown_gemini(self, video_info):
-        """Generate AI-powered scene breakdown using Gemini"""
-        if not self.gemini_model:
-            return self.generate_scene_breakdown_fallback(video_info)
-        
-        try:
-            duration = video_info.get('duration', 0)
-            title = video_info.get('title', '')
-            description = video_info.get('description', '')[:1500]  # Increased limit for better context
-            
-            if not duration:
-                return ["**[Duration Unknown]**: Unable to generate timestamped breakdown - video duration not available"]
-            
-            # Create enhanced prompt for Gemini
-            prompt = f"""
-            Analyze this YouTube video and create a highly detailed, scene-by-scene breakdown with precise timestamps and specific descriptions:
-            
-            Title: {title}
-            Duration: {duration} seconds
-            Description: {description}
-            
-            IMPORTANT INSTRUCTIONS:
-            1. Create detailed scene descriptions that include:
-               - Physical appearance of people (age, gender, clothing, hair, etc.)
-               - Exact actions being performed
-               - Dialogue or speech (include actual lines if audible, or infer probable spoken lines based on actions and setting; format them as "Character: line...")
-               - Setting and environment details
-               - Props, objects, or products being shown
-               - Visual effects, text overlays, or graphics
-               - Mood, tone, and atmosphere
-               - Camera movements or angles (if apparent)
-            2. Dialogue Emphasis:
-               - Include short dialogue lines in **every scene** wherever plausible.
-               - Write lines like: Character: "Actual or inferred line..."
-               - If dialogue is not available, intelligently infer probable phrases (e.g., "Welcome!", "Try this now!", "It feels amazing!").
-               - Do NOT skip dialogue unless it's clearly impossible.
+            # Find the downloaded file
+            for ext in ['.m4a', '.webm', '.mp4', '.mp3']:
+                potential_file = output_path + ext
+                if os.path.exists(potential_file):
+                    return potential_file
             
-            3. Timestamp Guidelines:
-               - For videos under 1 minute: 2-3 second segments
-               - For videos 1-5 minutes: 3-5 second segments  
-               - For videos 5-15 minutes: 5-10 second segments
-               - For videos over 15 minutes: 10-15 second segments
-               - Maximum 20 scenes total for longer videos
-            
-            4. Format each scene EXACTLY like this:
-               **[MM:SS-MM:SS]**: Detailed description including who is visible, what they're wearing, what they're doing, what they're saying (if applicable), setting details, objects shown, and any visual elements.
-            
-                      
-            5. Write descriptions as if you're watching the video in real-time, noting everything visible and audible.
-                        
-            Based on the title and description, intelligently infer what would likely happen in each time segment. Consider the video type and create contextually appropriate, detailed descriptions.
-            """
-            
-            response = self.gemini_model.generate_content(prompt)
-            
-            # Parse the response into individual scenes
-            if response and response.text:
-                scenes = []
-                lines = response.text.split('\n')
-                current_scene = ""
-                
-                for line in lines:
-                    line = line.strip()
-                    if line.strip().startswith("**[") and "]**:" in line:
-                        # This is a new scene timestamp line
-                        if current_scene:
-                            scenes.append(current_scene.strip())
-                        current_scene = line.strip()
-                    elif current_scene:
-                        # This is continuation of the current scene description
-                        current_scene += "\n" + line.strip()
-
-                # Add the last scene if exists
-                if current_scene:
-                    scenes.append(current_scene.strip())
-                    
-                return scenes if scenes else self.generate_scene_breakdown_fallback(video_info)
-            else:
-                return self.generate_scene_breakdown_fallback(video_info)
+            raise FileNotFoundError(f"Downloaded audio file not found")
                 
-        except Exception as e:
-            print(f"Gemini API error: {e}")
-            return self.generate_scene_breakdown_fallback(video_info)
-
-    def generate_scene_breakdown_fallback(self, video_info):
-        """Enhanced fallback scene generation when Gemini is not available"""
-        duration = video_info.get('duration', 0)
-        title = video_info.get('title', '').lower()
-        description = video_info.get('description', '').lower()
-        uploader = video_info.get('uploader', 'Content creator')
-        
-        if not duration:
-            return ["**[Duration Unknown]**: Unable to generate timestamped breakdown"]
-        
-        # Determine segment length based on duration
-        if duration <= 60:
-            segment_length = 3
-        elif duration <= 300:
-            segment_length = 5
-        elif duration <= 900:
-            segment_length = 10
-        else:
-            segment_length = 15
-            
-        scenes = []
-        num_segments = min(duration // segment_length + 1, 20)
-        
-        # Detect video type for better descriptions
-        video_type = self.detect_video_type_detailed(title, description)
-        
-        for i in range(num_segments):
-            start_time = i * segment_length
-            end_time = min(start_time + segment_length - 1, duration)
-            
-            start_formatted = f"{start_time//60}:{start_time%60:02d}"
-            end_formatted = f"{end_time//60}:{end_time%60:02d}"
-            
-            # Generate contextual descriptions based on video type and timing
-            desc = self.generate_contextual_description(i, num_segments, video_type, uploader, title)
-            
-            scenes.append(f"**[{start_formatted}-{end_formatted}]**: {desc}")
-        
-        return scenes
-
-    def detect_video_type_detailed(self, title, description):
-        """Detect video type with more detail for better fallback descriptions"""
-        text = (title + " " + description).lower()
-        
-        if any(word in text for word in ['tutorial', 'how to', 'guide', 'learn', 'diy', 'step by step']):
-            return 'tutorial'
-        elif any(word in text for word in ['review', 'unboxing', 'test', 'comparison', 'vs']):
-            return 'review'
-        elif any(word in text for word in ['vlog', 'daily', 'routine', 'day in', 'morning', 'skincare']):
-            return 'vlog'
-        elif any(word in text for word in ['music', 'song', 'cover', 'lyrics', 'dance']):
-            return 'music'
-        elif any(word in text for word in ['comedy', 'funny', 'prank', 'challenge', 'reaction']):
-            return 'entertainment'
-        elif any(word in text for word in ['news', 'breaking', 'update', 'report']):
-            return 'news'
-        elif any(word in text for word in ['cooking', 'recipe', 'food', 'kitchen']):
-            return 'cooking'
-        elif any(word in text for word in ['workout', 'fitness', 'exercise', 'yoga']):
-            return 'fitness'
-        else:
-            return 'general'
-
-    def generate_contextual_description(self, scene_index, total_scenes, video_type, uploader, title):
-        """Generate contextual descriptions based on video type and scene position"""
-        
-        # Common elements
-        presenter_desc = f"The content creator"
-        if 'woman' in title.lower() or 'girl' in title.lower():
-            presenter_desc = "A woman"
-        elif 'man' in title.lower() or 'guy' in title.lower():
-            presenter_desc = "A man"
-        
-        # Position-based descriptions
-        if scene_index == 0:
-            # Opening scene
-            if video_type == 'tutorial':
-                return f"{presenter_desc} appears on screen, likely introducing themselves and the topic. They may be in a well-lit indoor setting, wearing casual clothing, and addressing the camera directly with a welcoming gesture."
-            elif video_type == 'vlog':
-                return f"{presenter_desc} greets the camera with a smile, possibly waving. They appear to be in their usual filming location, wearing their typical style, and beginning their introduction to today's content."
-            elif video_type == 'review':
-                return f"{presenter_desc} introduces the product or topic they'll be reviewing, likely holding or displaying the item. The setting appears organized, possibly with the product prominently featured."
-            else:
-                return f"{presenter_desc} appears on screen to begin the video, introducing the topic with engaging body language and clear speech directed at the audience."
-        
-        elif scene_index == total_scenes - 1:
-            # Closing scene
-            if video_type == 'tutorial':
-                return f"{presenter_desc} concludes the tutorial, possibly showing the final result. They may be thanking viewers, asking for engagement (likes/comments), and suggesting related content."
-            elif video_type == 'vlog':
-                return f"{presenter_desc} wraps up their vlog, possibly reflecting on the day's events. They appear relaxed and are likely saying goodbye to viewers with a friendly gesture."
-            else:
-                return f"{presenter_desc} concludes the video with final thoughts, thanking viewers for watching, and encouraging engagement through likes, comments, and subscriptions."
-        
-        else:
-            # Middle scenes - content-specific
-            if video_type == 'tutorial':
-                step_num = scene_index
-                return f"{presenter_desc} demonstrates step {step_num} of the process, showing specific techniques and explaining the procedure. They may be using tools or materials, with close-up shots of their hands working."
-            
-            elif video_type == 'review':
-                return f"{presenter_desc} examines different aspects of the product, pointing out features and sharing their opinions. They may be holding, using, or demonstrating the item while speaking to the camera."
-            
-            elif video_type == 'vlog':
-                return f"{presenter_desc} continues sharing their experience, possibly showing different locations or activities. The scene captures candid moments with natural lighting and casual interactions."
-            
-            elif video_type == 'cooking':
-                return f"{presenter_desc} works in the kitchen, preparing ingredients or cooking. They demonstrate techniques while explaining each step, with kitchen tools and ingredients visible on the counter."
-            
-            elif video_type == 'fitness':
-                return f"{presenter_desc} demonstrates exercise movements, likely in workout attire in a gym or home setting. They show proper form while providing instruction and motivation."
-            
-            else:
-                return f"{presenter_desc} continues with the main content, engaging with the audience through clear explanations and demonstrations. The setting remains consistent with good lighting and clear audio."
+    except Exception as e:
+        raise Exception(f"Failed to download audio: {str(e)}")
 
-    def detect_video_type(self, title, description):
-        """Detect video type based on title and description"""
-        text = (title + " " + description).lower()
-        
-        if any(word in text for word in ['music', 'song', 'album', 'artist', 'band', 'lyrics']):
-            return "🎵 Music Video"
-        elif any(word in text for word in ['tutorial', 'how to', 'guide', 'learn', 'teaching']):
-            return "📚 Tutorial/Educational"
-        elif any(word in text for word in ['funny', 'comedy', 'entertainment', 'vlog', 'challenge']):
-            return "🎭 Entertainment/Comedy"
-        elif any(word in text for word in ['news', 'breaking', 'report', 'update']):
-            return "📰 News/Information"
-        elif any(word in text for word in ['review', 'unboxing', 'test', 'comparison']):
-            return "⭐ Review/Unboxing"
-        elif any(word in text for word in ['commercial', 'ad', 'brand', 'product']):
-            return "📺 Commercial/Advertisement"
-        else:
-            return "🎬 General Content"
+def transcribe_audio(file_path):
+    """Transcribe audio file using Whisper"""
+    if not WHISPER_AVAILABLE:
+        raise Exception("OpenAI Whisper is not available. Please check the installation.")
+    
+    try:
+        # Use the smallest model to reduce memory usage
+        model = whisper.load_model("tiny")
+        result = model.transcribe(file_path)
+        return result["text"]
+    except Exception as e:
+        raise Exception(f"Failed to transcribe audio: {str(e)}")
 
-    def detect_background_music(self, video_info):
-        """Detect background music style"""
-        title = video_info.get('title', '').lower()
-        description = video_info.get('description', '').lower()
+def extract_stock_info_simple(text):
+    """Extract stock information using simple pattern matching"""
+    try:
+        stock_info = []
+        
+        # Simple patterns to look for stock-related information
+        stock_patterns = [
+            r'\b[A-Z]{1,5}\b(?:\s+stock|\s+shares|\s+symbol)',  # Stock symbols
+            r'(?:buy|sell|target|price)\s+[A-Z]{1,5}',
+            r'\$\d+(?:\.\d{2})?',  # Dollar amounts
+            r'\b(?:bullish|bearish|buy|sell|hold)\b',
+        ]
+        
+        # Look for company names and stock mentions
+        companies = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*(?:\s+(?:Inc|Corp|Company|Ltd)\.?)?', text)
+        symbols = re.findall(r'\b[A-Z]{2,5}\b', text)
+        prices = re.findall(r'\$\d+(?:\.\d{2})?', text)
+        actions = re.findall(r'\b(?:buy|sell|hold|bullish|bearish|target|stop\s+loss)\b', text, re.IGNORECASE)
+        
+        # Format the extracted information
+        result = "=== EXTRACTED STOCK INFORMATION ===\n\n"
+        
+        if companies:
+            result += f"📊 Mentioned Companies: {', '.join(set(companies[:10]))}\n\n"
+        
+        if symbols:
+            result += f"🔤 Potential Stock Symbols: {', '.join(set(symbols[:10]))}\n\n"
+        
+        if prices:
+            result += f"💰 Price Mentions: {', '.join(set(prices[:10]))}\n\n"
+        
+        if actions:
+            result += f"📈 Trading Actions: {', '.join(set(actions[:10]))}\n\n"
+        
+        # Look for specific recommendation patterns
+        recommendations = []
+        sentences = text.split('.')
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ['buy', 'sell', 'target', 'recommendation']):
+                if any(symbol in sentence for symbol in symbols[:5]):
+                    recommendations.append(sentence.strip())
+        
+        if recommendations:
+            result += "🎯 Potential Recommendations:\n"
+            for rec in recommendations[:5]:
+                result += f"• {rec}\n"
+        
+        if not any([companies, symbols, prices, actions]):
+            result += "⚠️ No clear stock recommendations found in the transcript.\n"
+            result += "This might be because:\n"
+            result += "• The video doesn't contain stock recommendations\n"
+            result += "• The audio quality was poor\n"
+            result += "• The content is not in English\n"
         
-        if any(word in title for word in ['music', 'song', 'soundtrack']):
-            return "🎵 Original Music/Soundtrack - Primary audio content"
-        elif any(word in title for word in ['commercial', 'ad', 'brand']):
-            return "🎶 Upbeat Commercial Music - Designed to enhance brand appeal"
-        elif any(word in title for word in ['tutorial', 'how to', 'guide']):
-            return "🔇 Minimal/No Background Music - Focus on instruction"
-        elif any(word in title for word in ['vlog', 'daily', 'life']):
-            return "🎼 Ambient Background Music - Complementary to narration"
-        else:
-            return "🎵 Background Music - Complementing video mood and pacing"
-
-    def detect_influencer_status(self, video_info):
-        """Detect influencer status"""
-        subscriber_count = video_info.get('channel_followers', 0)
-        view_count = video_info.get('view_count', 0)
+        return result
         
-        if subscriber_count > 10000000:
-            return "🌟 Mega Influencer (10M+ subscribers)"
-        elif subscriber_count > 1000000:
-            return "⭐ Major Influencer (1M+ subscribers)"
-        elif subscriber_count > 100000:
-            return "🎯 Mid-tier Influencer (100K+ subscribers)"
-        elif subscriber_count > 10000:
-            return "📈 Micro Influencer (10K+ subscribers)"
-        elif view_count > 100000:
-            return "🔥 Viral Content Creator"
-        else:
-            return "👤 Regular Content Creator"
-
-    def format_number(self, num):
-        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"
-        return str(num)
+    except Exception as e:
+        return f"Error extracting stock info: {str(e)}"
 
-    def format_video_info(self, video_info):
-        """Compact video information formatting with tabular layout"""
-        if not video_info:
-            return "❌ No video information available."
-    
-        # Basic information
-        title = video_info.get("title", "Unknown")
-        uploader = video_info.get("uploader", "Unknown")
-        duration = video_info.get("duration", 0)
-        duration_str = f"{duration//60}:{duration%60:02d}" if duration else "Unknown"
-        view_count = video_info.get("view_count", 0)
-        like_count = video_info.get("like_count", 0)
-        comment_count = video_info.get("comment_count", 0)
-        upload_date = video_info.get("upload_date", "Unknown")
-        
-        # Format upload date
-        if len(upload_date) == 8:
-            formatted_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:8]}"
-        else:
-            formatted_date = upload_date
+def cleanup_file(file_path):
+    """Clean up temporary files"""
+    try:
+        if file_path and os.path.exists(file_path):
+            os.remove(file_path)
+            # Also try to remove the directory if it's empty
+            try:
+                os.rmdir(os.path.dirname(file_path))
+            except:
+                pass
+    except:
+        pass
+
+def process_cookies_file(cookies_file):
+    """Process uploaded cookies file and return the path"""
+    if cookies_file is None:
+        return None
     
-        # Generate enhanced analysis
-        scene_descriptions = self.generate_scene_breakdown_gemini(video_info)
-        scene_table_html = format_scene_breakdown(scene_descriptions)
-        video_type = self.detect_video_type(title, video_info.get('description', ''))
-        background_music = self.detect_background_music(video_info)
-        influencer_status = self.detect_influencer_status(video_info)
+    try:
+        # Create a temporary file for cookies
+        temp_cookies_path = tempfile.mktemp(suffix='.txt')
         
-        # Calculate engagement metrics
-        engagement_rate = (like_count / view_count) * 100 if view_count > 0 else 0
+        # Copy the uploaded file to temp location
+        shutil.copy2(cookies_file.name, temp_cookies_path)
         
-        # Generate compact report with contrasting background
-        report = f"""
-    <div style='font-family: Arial, sans-serif; background: linear-gradient(135deg, #2d3748, #1a202c); padding: 20px; border-radius: 15px; border: 2px solid #FF8C00; box-shadow: 0 8px 32px rgba(255, 140, 0, 0.3);'>
-    
-        <div style='text-align: center; margin-bottom: 20px;'>
-            <h2 style='color: #87CEEB; font-size: 24px; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.5);'>🎬 YouTube Video Analysis Report</h2>
-            <div style='height: 3px; background: linear-gradient(90deg, #FF8C00, #87CEEB); margin: 10px 0; border-radius: 5px;'></div>
-        </div>
+        return temp_cookies_path
+    except Exception as e:
+        print(f"Error processing cookies file: {e}")
+        return None
+
+def process_video(url, cookies_file, progress=gr.Progress()):
+    """Main function to process YouTube video"""
     
-        <!-- Compact Information Grid -->
-        <div style='display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px; margin-bottom: 20px;'>
-            
-            <!-- Basic Information Card -->
-            <div style='background: rgba(135, 206, 235, 0.1); padding: 15px; border-radius: 10px; border-left: 4px solid #87CEEB;'>
-                <h3 style='color: #87CEEB; margin: 0 0 10px 0; font-size: 16px;'>📋 Basic Info</h3>
-                <table style='width: 100%; font-size: 14px;'>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>📹 Title:</td></tr>
-                    <tr><td style='color: #FFFFFF; padding: 4px 0 8px 0; word-wrap: wrap-word; white-space: normal; max-width: 200px;'>{title}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>👤 Creator:</td><td style='color: #FFFFFF; padding: 2px 0;'>{uploader[:20]}{'...' if len(uploader) > 20 else ''}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>📅 Date:</td><td style='color: #FFFFFF; padding: 2px 0;'>{formatted_date}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>⏱️ Duration:</td><td style='color: #FFFFFF; padding: 2px 0;'>{duration_str}</td></tr>
-                </table>
-            </div>
+    # Check if required packages are available
+    if not YT_DLP_AVAILABLE:
+        return "Error: yt-dlp is not installed properly. Please check the requirements.", "", "❌ Error: Missing yt-dlp"
     
-            <!-- Performance Metrics Card -->
-            <div style='background: rgba(135, 206, 235, 0.1); padding: 15px; border-radius: 10px; border-left: 4px solid #FF8C00;border: 1px solid #444'>
-                <h3 style='color: #87CEEB; margin: 0 0 10px 0; font-size: 16px;'>📊 Metrics</h3>
-                <table style='width: 100%; font-size: 12px;'>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>👀 Views:</td><td style='color: #FFFFFF; padding: 4px 0;'>{self.format_number(view_count)}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>👍 Likes:</td><td style='color: #FFFFFF; padding: 4px 0;'>{self.format_number(like_count)}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>💬 Comments:</td><td style='color: #FFFFFF; padding: 4px 0;'>{self.format_number(comment_count)}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>📈 Engagement:</td><td style='color: #FFFFFF; padding: 4px 0;'>{engagement_rate:.2f}%</td></tr>
-                </table>
-            </div>
+    if not WHISPER_AVAILABLE:
+        return "Error: OpenAI Whisper is not installed properly. Please check the requirements.", "", "❌ Error: Missing Whisper"
     
-            <!-- Content Analysis Card -->
-            <div style='background:rgba(135, 206, 235, 0.1); padding: 15px; border-radius: 10px; border-left: 4px solid #87CEEB;border: 1px solid #444'>
-                <h3 style='color:#87CEEB; margin: 0 0 10px 0; font-size: 16px;'>🎯 Analysis</h3>
-                <table style='width: 100%; font-size: 12px;'>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>📂 Type:</td></tr>
-                    <tr><td style='color: #FFFFFF; padding: 4px 0 8px 0; word-break: break-word;'>{video_type}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>🎵 Music:</td></tr>
-                    <tr><td style='color: #FFFFFF; padding: 4px 0 8px 0; word-break: break-word;'>{background_music[:30]}{'...' if len(background_music) > 30 else ''}</td></tr>
-                    <tr><td style='color: #87CEEB; font-weight: bold; padding: 4px 0;'>👑 Status:</td></tr>
-                    <tr><td style='color: #FFFFFF; padding: 4px 0; word-break: break-word;'>{influencer_status[:25]}{'...' if len(influencer_status) > 25 else ''}</td></tr>
-                </table>
-            </div>
-        </div>
+    if not url or not url.strip():
+        return "Please provide a valid YouTube URL", "", "❌ Error: Invalid URL"
     
-        <!-- Scene Breakdown Section -->
-        <div style='background: rgba(0, 0, 0, 0.3); padding: 15px; border-radius: 10px; border: 1px solid #444;'>
-            <h3 style='color: #87CEEB; margin: 0 0 15px 0; font-size: 18px; text-align: center;'>🎬 Scene-by-Scene Breakdown</h3>
-            {scene_table_html}
-        </div>
+    audio_path = None
+    cookies_temp_path = None
     
-    </div>
-    """
-        
-        return report.strip()
-        
-    def get_video_info(self, url, progress=gr.Progress(), cookiefile=None):
-        """Extract video information"""
-        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 format"
-        
-        try:
-            progress(0.1, desc="Initializing YouTube extractor...")
-            
-            ydl_opts = {
-                'noplaylist': True,
-                'extract_flat': False,
-            }
-            
-            if cookiefile and os.path.exists(cookiefile):
-                ydl_opts['cookiefile'] = cookiefile
-            
-            progress(0.5, desc="Extracting video metadata...")
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=False)
-                
-            progress(1.0, desc="✅ Analysis complete!")
-            
-            return info, "✅ Video information extracted successfully"
-            
-        except Exception as e:
-            return None, f"❌ Error: {str(e)}"
-
-    def download_video(self, url, quality="best", audio_only=False, progress=gr.Progress(), cookiefile=None):
-        """Download video with progress tracking"""
-        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 format"
-        
-        try:
-            progress(0.1, desc="Preparing download...")
-            
-            # Create unique filename
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            
-            # Download to temp directory first (Gradio compatible)
-            ydl_opts = {
-                'outtmpl': os.path.join(self.temp_downloads, f'%(title)s_{timestamp}.%(ext)s'),
-                'noplaylist': True,
-            }
-            
-            if audio_only:
-                ydl_opts['format'] = 'bestaudio/best'
-                ydl_opts['postprocessors'] = [{
-                    'key': 'FFmpegExtractAudio',
-                    'preferredcodec': 'mp3',
-                    'preferredquality': '192',
-                }]
-            else:
-                if quality == "best":
-                    ydl_opts['format'] = 'best[height<=1080]'
-                elif quality == "720p":
-                    ydl_opts['format'] = 'best[height<=720]'
-                elif quality == "480p":
-                    ydl_opts['format'] = 'best[height<=480]'
-                else:
-                    ydl_opts['format'] = 'best'
-            
-            if cookiefile and os.path.exists(cookiefile):
-                ydl_opts['cookiefile'] = cookiefile
-            
-            # Progress hook
-            def progress_hook(d):
-                if d['status'] == 'downloading':
-                    if 'total_bytes' in d:
-                        percent = (d['downloaded_bytes'] / d['total_bytes']) * 100
-                        progress(0.1 + (percent / 100) * 0.7, desc=f"Downloading... {percent:.1f}%")
-                    else:
-                        progress(0.5, desc="Downloading...")
-                elif d['status'] == 'finished':
-                    progress(0.8, desc="Processing download...")
-            
-            ydl_opts['progress_hooks'] = [progress_hook]
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=True)
-                
-            progress(0.9, desc="Copying to Downloads folder...")
-            
-            # Find the downloaded file in temp directory
-            downloaded_file_temp = None
-            
-            for file in os.listdir(self.temp_downloads):
-                if timestamp in file:
-                    downloaded_file_temp = os.path.join(self.temp_downloads, file)
-                    break
-            
-            if not downloaded_file_temp:
-                return None, "❌ Downloaded file not found in temp directory"
-            
-            # Copy to user's Downloads folder
-            final_filename = os.path.basename(downloaded_file_temp)
-            final_path = os.path.join(self.downloads_folder, final_filename)
-            
-            try:
-                shutil.copy2(downloaded_file_temp, final_path)
-                copy_success = True
-            except Exception as e:
-                print(f"Warning: Could not copy to Downloads folder: {e}")
-                copy_success = False
-                final_path = "File downloaded to temp location only"
-            
-            progress(1.0, desc="✅ Download complete!")
-            
-            success_msg = f"""✅ Download successful!
-📁 Temp file (for download): {os.path.basename(downloaded_file_temp)}
-📁 Permanent location: {final_path if copy_success else 'Copy failed'}
-🎯 File size: {os.path.getsize(downloaded_file_temp) / (1024*1024):.1f} MB"""
-            
-            return downloaded_file_temp, success_msg
-            
-        except Exception as e:
-            return None, f"❌ Download failed: {str(e)}"
-
-# Initialize global downloader
-downloader = YouTubeDownloader()
-
-def configure_api_key(api_key):
-    """Configure Gemini API key"""
-    if not api_key or not api_key.strip():
-        return "❌ Please enter a valid Google API key", gr.update(visible=False)
-    
-    success, message = downloader.configure_gemini(api_key.strip())
-    
-    if success:
-        return message, gr.update(visible=True)
-    else:
-        return message, gr.update(visible=False)
-
-def analyze_with_cookies(url, cookies_file, progress=gr.Progress()):
-    """Main analysis function"""
-    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)
-        
-        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)}"
-
-
-def analyze_and_generate_pdf(url, cookies_file, progress=gr.Progress()):
-    try:
-        progress(0.1, desc="Extracting video info...")
-        cookiefile = cookies_file if cookies_file and os.path.exists(cookies_file) else None
-        info, _ = downloader.get_video_info(url, progress=progress, cookiefile=cookiefile)
-
-        if not info:
-            print("⚠️ No video info returned.")
-            return None  # This is the problem - returns None instead of Gradio update
-
-        progress(0.6, desc="Generating HTML report...")
-        report_html = downloader.format_video_info(info)
-
-        progress(0.8, desc="Creating PDF...")
-        pdf_buffer = generate_pdf_from_html(report_html)
-
-        if pdf_buffer:
-            pdf_path = os.path.join(downloader.downloads_folder, f"analysis_report_{uuid.uuid4().hex}.pdf")
-            with open(pdf_path, "wb") as f:
-                f.write(pdf_buffer.read())
-            print("✅ PDF generated at:", pdf_path)
-            print("File exists:", os.path.exists(pdf_path))  
-            
-            progress(1.0, desc="✅ PDF ready!")
-            return pdf_path  # This should return a Gradio update
-        else:
-            print("❌ PDF buffer is empty.")
-            return None # This should return a Gradio update
-
-    except Exception as e:
-        print(f"PDF generation error: {e}")
-        return None  # This should return a Gradio update
-
-def generate_pdf_from_html(html_content):
-    """Generate PDF with simplified HTML that works better with xhtml2pdf"""
     try:
-        # Create a simplified version of the HTML for PDF generation
-        # Remove complex CSS that xhtml2pdf can't handle
-        simplified_html = html_content.replace(
-            "background: linear-gradient(135deg, #2d3748, #1a202c);", 
-            "background-color: #f5f5f5;"
-        ).replace(
-            "background: linear-gradient(90deg, #FF8C00, #87CEEB);", 
-            "background-color: #FF8C00;"
-        ).replace(
-            "rgba(135, 206, 235, 0.1)", 
-            "#f9f9f9"
-        ).replace(
-            "rgba(0, 0, 0, 0.3)", 
-            "#ffffff"
-        ).replace(
-            "text-shadow: 2px 2px 4px rgba(0,0,0,0.5);", 
-            ""
-        ).replace(
-            "box-shadow: 0 8px 32px rgba(255, 140, 0, 0.3);", 
-            ""
-        ).replace(
-            "box-shadow: 0 4px 8px rgba(0,0,0,0.3);", 
-            ""
-        ).replace(
-            "display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px;", 
-            "display: block;"
-        ).replace(
-            "background-color:#1a1a1a;", 
-            "background-color:#ffffff;"
-        ).replace(
-            "color: #FFFFFF;", 
-            "color: #000000;"
-        ).replace(
-            "background-color:#FF8C00; color: #000000;", 
-            "background-color:#FF8C00; color: #000000;"
-        ).replace(
-            "color: #87CEEB;", 
-            "color: #000080;"
-        ).replace(
-            "border: 2px solid #FF8C00;", 
-            "border: 1px solid #FF8C00;"
-        )
+        # Validate URL
+        if not any(domain in url.lower() for domain in ['youtube.com', 'youtu.be']):
+            return "Please provide a valid YouTube URL", "", "❌ Error: Invalid URL"
         
-        # Remove table styling that causes issues
-        simplified_html = re.sub(r"style='[^']*background-color:#1a1a1a[^']*'", "style='background-color:#ffffff;'", simplified_html)
-        simplified_html = re.sub(r"style='[^']*color: #87CEEB[^']*'", "style='color: #000080; padding: 8px;'", simplified_html)
+        # Process cookies file if provided
+        progress(0.05, desc="Processing cookies...")
+        cookies_temp_path = process_cookies_file(cookies_file)
         
-        # Wrap in a complete HTML document with PDF-friendly CSS
-        pdf_html = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <meta charset="UTF-8">
-            <style>
-                @page {{
-                    size: A4;
-                    margin: 1cm;
-                }}
-                body {{ 
-                    font-family: Arial, sans-serif; 
-                    font-size: 12px;
-                    line-height: 1.4;
-                    color: #000000;
-                    background-color: #ffffff;
-                }}
-                .report-container {{
-                    background-color: #ffffff;
-                    padding: 15px;
-                    border: 2px solid #FF8C00;
-                    border-radius: 8px;
-                }}
-                .header {{
-                    text-align: center;
-                    color: #FF8C00;
-                    font-size: 20px;
-                    font-weight: bold;
-                    margin-bottom: 15px;
-                    border-bottom: 2px solid #FF8C00;
-                    padding-bottom: 8px;
-                }}
-                .info-card {{
-                    background-color: #f9f9f9;
-                    padding: 12px;
-                    margin: 8px 0;
-                    border-left: 3px solid #87CEEB;
-                    border-radius: 4px;
-                    page-break-inside: avoid;
-                }}
-                .info-title {{
-                    color: #000080;
-                    font-size: 14px;
-                    font-weight: bold;
-                    margin-bottom: 8px;
-                }}
-                table {{
-                    width: 100%;
-                    border-collapse: collapse;
-                    margin: 8px 0;
-                    page-break-inside: avoid;
-                }}
-                th, td {{
-                    padding: 6px 8px;
-                    border: 1px solid #cccccc;
-                    text-align: left;
-                    vertical-align: top;
-                    font-size: 11px;
-                }}
-                th {{
-                    background-color: #FF8C00;
-                    color: #000000;
-                    font-weight: bold;
-                }}
-                tr:nth-child(even) {{
-                    background-color: #f9f9f9;
-                }}
-                .scene-table {{
-                    margin-top: 15px;
-                }}
-                .scene-header {{
-                    color: #000080;
-                    font-size: 16px;
-                    font-weight: bold;
-                    text-align: center;
-                    margin-bottom: 10px;
-                }}
-                div[style*="display: grid"] {{
-                    display: block !important;
-                }}
-                div[style*="grid-template-columns"] > div {{
-                    display: block !important;
-                    margin-bottom: 10px !important;
-                    width: 100% !important;
-                }}
-            </style>
-        </head>
-        <body>
-            <div class="report-container">
-                {simplified_html}
-            </div>
-        </body>
-        </html>
-        """
+        status_msg = "✅ Cookies loaded" if cookies_temp_path else "⚠️ No cookies (may encounter bot detection)"
         
-        result = BytesIO()
-        pisa_status = pisa.CreatePDF(pdf_html, dest=result)
+        # Download audio
+        progress(0.2, desc="Downloading audio...")
+        audio_path = download_audio(url, cookies_temp_path)
         
-        if pisa_status.err:
-            print(f"PDF generation error: {pisa_status.err}")
-            return None
-            
-        result.seek(0)
-        return result
+        # Transcribe audio
+        progress(0.6, desc="Transcribing audio...")
+        transcript = transcribe_audio(audio_path)
         
-    except Exception as e:
-        print(f"PDF generation exception: {e}")
-        return None
-
-
-
-def download_with_cookies(url, quality, audio_only, cookies_file, progress=gr.Progress()):
-    """Main download function"""
-    try:
-        progress(0.05, desc="Preparing download...")
+        if not transcript.strip():
+            return "No speech detected in the video", "", "❌ No speech detected"
         
-        cookiefile = None
-        if cookies_file and os.path.exists(cookies_file):
-            cookiefile = cookies_file
+        # Extract stock information
+        progress(0.9, desc="Extracting stock information...")
+        stock_details = extract_stock_info_simple(transcript)
         
-        file_path, msg = downloader.download_video(url, quality, audio_only, progress=progress, cookiefile=cookiefile)
+        progress(1.0, desc="Complete!")
+        return transcript, stock_details, "✅ Processing completed successfully"
         
-        if file_path:
-            return file_path, msg
-        else:
-            return None, msg
-            
     except Exception as e:
-        return None, f"❌ System Error: {str(e)}"
-
-def create_interface():
-    """Create and configure the Gradio interface"""
-    with gr.Blocks(
-          css="""
-        /* Main dark theme background and text */
-        .gradio-container, .app, body {
-            background-color: #1a1a1a !important;
-            color: #87CEEB !important;
-            font-weight: bold !important;
-        }
-                /* 🔵 Dark blue overrides for key labels */
-        h3, .gr-group h3, .gradio-container h3 {
-            color: #87CEEB !important;
-        }
-        label, .gr-textbox label, .gr-file label, .gr-dropdown label, .gr-checkbox label {
-            color: #00008B !important;
-            font-weight: bold !important;
-        }
-        .gr-file .file-name {
-            color: #00008B !important;
-            font-weight: bold !important;
-        }
-        /* Make tab labels dark blue too */
-        .gr-tab-nav button {
-            color: #00008B !important;
-        }
-        .gr-tab-nav button.selected {
-            background-color: #FF8C00 !important;
-            color: #000000 !important;
-        }
-        /* Light blue text for API status */
-        .light-blue-text textarea {
-            color: #87CEEB !important;
-            background-color: #2a2a2a !important;
-        }
-        .gr-file {
-            background-color: #2a2a2a !important;
-            border: 2px dashed #444 !important;
-        }
-        .gr-group, .gr-form, .gr-row {
-            background-color: #1a1a1a !important;
-            border: 1px solid #444 !important;
-            border-radius: 10px;
-            padding: 15px;
-        }
-    """,
-        theme=gr.themes.Soft(),
-        title="📊 YouTube Video Analyzer & Downloader"
-    ) as demo:
-        
-        # API Key Configuration Section
-        with gr.Group():
-            gr.HTML("<h3>🔑 Google Gemini API Configuration</h3>")
-            with gr.Row():
-                api_key_input = gr.Textbox(
-                    label="🔑 Google API Key",
-                    placeholder="Enter your Google API Key for enhanced AI analysis...",
-                    type="password",
-                    value=""
-                )
-                configure_btn = gr.Button("🔧 Configure API", variant="secondary")
-            
-            api_status = gr.Textbox(
-                label="API Status",
-                value="❌ Gemini API not configured - Using fallback analysis",
-                interactive=False,
-                lines=1,
-                elem_classes="light-blue-text"
+        error_msg = f"Error processing video: {str(e)}"
+        return error_msg, "", f"❌ Error: {str(e)}"
+    
+    finally:
+        # Clean up temporary files
+        cleanup_file(audio_path)
+        cleanup_file(cookies_temp_path)
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Stock Recommendation Extractor",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 1400px;
+        margin: auto;
+    }
+    .status-box {
+        padding: 10px;
+        border-radius: 5px;
+        margin: 10px 0;
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 📈 Stock Recommendation Extractor from YouTube
+    
+    Extract stock recommendations and trading information from YouTube videos using AI transcription.
+    
+    **How it works:**
+    1. Upload your cookies.txt file (optional but recommended to avoid bot detection)
+    2. Paste YouTube video URL
+    3. Downloads audio from YouTube video
+    4. Transcribes using OpenAI Whisper
+    5. Extracts stock-related information
+    
+    **⚠️ Disclaimer:** This is for educational purposes only. Always do your own research!
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Cookies file upload
+            cookies_input = gr.File(
+                label="🍪 Upload Cookies File (cookies.txt)",
+                file_types=[".txt"],
+                file_count="single"
             )
             
-            # Main Interface (initially hidden until API is configured)
-            main_interface = gr.Group(visible=False)
+            gr.Markdown("""
+            **How to get cookies.txt:**
+            1. Install browser extension like "Get cookies.txt LOCALLY"
+            2. Visit YouTube in your browser (logged in)
+            3. Export cookies for youtube.com
+            4. Upload the downloaded cookies.txt file here
+            """)
             
-            with main_interface:
-                with gr.Row():
-                    url_input = gr.Textbox(
-                        label="🔗 YouTube URL",
-                        placeholder="Paste your YouTube video URL here...",
-                        value=""
-                    )
-                    
-                    cookies_input = gr.File(
-                        label="🍪 Upload cookies.txt (Mandatory)",
-                        file_types=[".txt"],
-                        type="filepath"
-                    )
-                
-                with gr.Tabs():
-                    with gr.TabItem("📊 Video Analysis"):
-                        analyze_btn = gr.Button("🔍 Analyze Video", variant="primary")
-                        
-                        analysis_output = gr.HTML(
-                            label="📊 Analysis Report",
-                        )
-                        download_pdf_btn = gr.Button("📄 Download Report as PDF", variant="secondary")
-                        pdf_file_output = gr.File(label="📥 PDF Report", visible=False,interactive=False)
-
-                    analyze_btn.click(
-                        fn=analyze_with_cookies,
-                        inputs=[url_input, cookies_input],
-                        outputs=analysis_output,
-                        show_progress=True
-                    )
-                    download_pdf_btn.click(
-                        fn=analyze_and_generate_pdf,
-                        inputs=[url_input, cookies_input],
-                        outputs=pdf_file_output,
-                        show_progress=True
-                    )
-                                                      
-                    
-                    with gr.TabItem("⬇️ Video Download"):
-                        with gr.Row():
-                            quality_dropdown = gr.Dropdown(
-                                choices=["best", "720p", "480p"],
-                                value="best",
-                                label="📺 Video Quality"
-                            )
-                            
-                            audio_only_checkbox = gr.Checkbox(
-                                label="🎵 Audio Only (MP3)",
-                                value=False
-                            )
-                        
-                        download_btn = gr.Button("⬇️ Download Video", variant="primary")
-                        
-                        download_status = gr.Textbox(
-                            label="📥 Download Status",
-                            lines=5,
-                            show_copy_button=True
-                        )
-                        
-                        download_file = gr.File(
-                            label="📁 Downloaded File",
-                            visible=False
-                        )
-                        
-                        def download_and_update(url, quality, audio_only, cookies_file, progress=gr.Progress()):
-                            file_path, status = download_with_cookies(url, quality, audio_only, cookies_file, progress)
-                            if file_path and os.path.exists(file_path):
-                                return status, gr.update(value=file_path, visible=True)
-                            else:
-                                return status, gr.update(visible=False)
-                        
-                        download_btn.click(
-                            fn=download_and_update,
-                            inputs=[url_input, quality_dropdown, audio_only_checkbox, cookies_input],
-                            outputs=[download_status, download_file],
-                            show_progress=True
-                        )
+            url_input = gr.Textbox(
+                label="📺 YouTube URL",
+                placeholder="https://www.youtube.com/watch?v=...",
+                lines=2
+            )
             
-            # Configure API key button action
-            configure_btn.click(
-                fn=configure_api_key,
-                inputs=[api_key_input],
-                outputs=[api_status, main_interface]
+            process_btn = gr.Button(
+                "🚀 Extract Stock Information", 
+                variant="primary",
+                size="lg"
             )
             
-            # Always show interface option (for fallback mode)
-            with gr.Row():
-                show_interface_btn = gr.Button("🚀 Use Without Gemini API (Fallback Mode)", variant="secondary")
-                
-                def show_fallback_interface():
-                    return "⚠️ Using fallback analysis mode", gr.update(visible=True)
-                
-                show_interface_btn.click(
-                    fn=show_fallback_interface,
-                    outputs=[api_status, main_interface]
-                )
+            # Status display
+            status_output = gr.Textbox(
+                label="📊 Status",
+                lines=1,
+                interactive=False
+            )
             
-            gr.HTML("""
-            <div style="margin-top: 20px; padding: 15px; background-color: #2a2a2a; border-radius: 10px; border-left: 5px solid #FF8C00; color: #87CEEB !important;">
-                <h3 style="color: #87CEEB !important; font-weight: bold;">🔑 How to Get Google API Key:</h3>
-                <ol style="color: #87CEEB !important; font-weight: bold;">
-                    <li style="color: #87CEEB !important;">Go to <a href="https://console.cloud.google.com/" target="_blank" style="color: #87CEEB !important;">Google Cloud Console</a></li>
-                    <li style="color: #87CEEB !important;">Create a new project or select an existing one</li>
-                    <li style="color: #87CEEB !important;">Enable the "Generative Language API"</li>
-                    <li style="color: #87CEEB !important;">Go to "Credentials" and create an API key</li>
-                    <li style="color: #87CEEB !important;">Copy the API key and paste it above</li>
-                </ol>
-                <h3 style="color: #87CEEB !important; font-weight: bold;">✨ Benefits of using Gemini API:</h3>
-                <ul style="color: #87CEEB !important; font-weight: bold;">
-                    <li style="color: #87CEEB !important;">🤖 AI-powered scene descriptions with contextual understanding</li>
-                    <li style="color: #87CEEB !important;">🎯 More accurate content type detection</li>
-                    <li style="color: #87CEEB !important;">📊 Enhanced analysis based on video content</li>
-                    <li style="color: #87CEEB !important;">⏰ Intelligent timestamp segmentation</li>
-                </ul>
-            </div>
+            gr.Markdown("""
+            ### 💡 Tips:
+            - Upload cookies.txt to avoid bot detection
+            - Works best with financial YouTube channels
+            - Ensure video has clear audio
+            - English content works best
             """)
     
-    return demo
+    with gr.Row():
+        with gr.Column():
+            transcript_output = gr.Textbox(
+                label="📝 Full Transcript",
+                lines=15,
+                max_lines=20,
+                show_copy_button=True
+            )
+        
+        with gr.Column():
+            stock_info_output = gr.Textbox(
+                label="📊 Extracted Stock Information",
+                lines=15,
+                max_lines=20,
+                show_copy_button=True
+            )
+    
+    # Event handlers
+    process_btn.click(
+        fn=process_video,
+        inputs=[url_input, cookies_input],
+        outputs=[transcript_output, stock_info_output, status_output],
+        show_progress=True
+    )
+    
+    # Example section
+    gr.Markdown("### 📋 Example URLs (Replace with actual financial videos)")
+    gr.Examples(
+        examples=[
+            ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
+        ],
+        inputs=[url_input],
+        label="Click to try example"
+    )
+    
+    gr.Markdown("""
+    ### 🔧 Troubleshooting:
+    - **Bot Detection Error**: Upload your cookies.txt file
+    - **No Audio Found**: Check if video has audio track
+    - **Transcription Failed**: Video might be too long or audio quality poor
+    - **No Stock Info**: Video might not contain financial content
+    """)
+
 if __name__ == "__main__":
-    demo = create_interface()
-    import atexit
-    atexit.register(downloader.cleanup)
-    demo.launch(debug=True, show_error=True)
+    demo.launch()