Update app.py

app.py

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 """
-YouTube Comment Sentiment Analyzer - Complete Working Version
-Compatible with Python 3.11
+YouTube Comment Sentiment Analyzer - WITH PROPER URDU SUPPORT
+Uses XLM-RoBERTa model for Roman Urdu sentiment
 """
 
 import gradio as gr
 import pandas as pd
 import numpy as np
 import matplotlib
-matplotlib.use('Agg')  # Use non-interactive backend for server
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 import seaborn as sns
 import re
@@ -22,61 +22,94 @@ from googleapiclient.errors import HttpError
 import warnings
 warnings.filterwarnings('ignore')
 
-# Try to import emoji (optional feature)
+# For Urdu sentiment analysis
+from transformers import pipeline
+
+# For emoji
 try:
     import emoji
     EMOJI_AVAILABLE = True
 except ImportError:
     EMOJI_AVAILABLE = False
 
-# Set seed for consistent language detection
 DetectorFactory.seed = 0
-
-# Set matplotlib style
 plt.style.use('seaborn-v0_8-darkgrid')
 sns.set_palette("husl")
 
-# Get YouTube API key from Hugging Face Secrets
 YOUTUBE_API_KEY = os.environ.get("GoogleAPIKey")
 
-# Custom stopwords for wordcloud
-CUSTOM_STOPWORDS = {
-    'imran', 'khan', 'pti', 'pakistan', 'people', 'say', 'would', 'could',
-    'should', 'like', 'just', 'get', 'really', 'got', 'even', 'also', 'well',
-    'one', 'two', 'see', 'go', 'make', 'time', 'way', 'will', 'can', 'know',
-    'video', 'watch', 'comment', 'channel', 'please', 'subscribe', 'like'
-}
+# Load Roman Urdu sentiment model
+print("Loading Urdu sentiment model...")
+try:
+    urdu_sentiment_pipeline = pipeline(
+        "text-classification",
+        model="Khubaib01/roman-urdu-sentiment-xlm-r",
+        truncation=True,
+        device=-1
+    )
+    URDU_MODEL_AVAILABLE = True
+    print("✅ Urdu sentiment model loaded successfully")
+except Exception as e:
+    print(f"⚠️ Could not load Urdu model: {e}")
+    print("Will use enhanced Urdu keyword matching as fallback")
+    URDU_MODEL_AVAILABLE = False
+
+# Urdu positive and negative keywords for fallback
+URDU_POSITIVE_KEYWORDS = [
+    'zinda bad', 'زنده باد', 'long live',
+    'nice', 'good', 'great', 'best', 'love', 'like', 'support',
+    'حق', 'truth', 'صحیح', 'correct',
+    'پاکستان', 'pakistan', 'قائد', 'leader',
+    'تحریک', 'movement', 'انسانی', 'human'
+]
 
+URDU_NEGATIVE_KEYWORDS = [
+    'bad', 'برا', 'wrong', 'غلط', 'hate', 'نفرت',
+    'corrupt', 'کرپٹ', 'false', 'جھوٹ', 'liar', 'جھوٹا'
+]
+
+def analyze_urdu_sentiment_enhanced(text):
+    """Enhanced Urdu sentiment analysis"""
+    text_lower = text.lower()
+    
+    # Check for positive Urdu phrases
+    positive_score = 0
+    negative_score = 0
+    
+    for keyword in URDU_POSITIVE_KEYWORDS:
+        if keyword in text_lower:
+            positive_score += 1
+    
+    for keyword in URDU_NEGATIVE_KEYWORDS:
+        if keyword in text_lower:
+            negative_score += 1
+    
+    # Special handling for "zinda bad" pattern
+    if 'zinda bad' in text_lower or 'زنده باد' in text_lower:
+        positive_score += 3  # Strong positive
+    
+    if positive_score > negative_score:
+        return 'Positive', min(0.9, 0.5 + (positive_score * 0.1))
+    elif negative_score > positive_score:
+        return 'Negative', min(0.9, 0.5 + (negative_score * 0.1))
+    else:
+        return 'Neutral', 0.5
 
 class YouTubeSentimentAnalyzer:
-    """Main analyzer class for YouTube comments"""
-    
     def __init__(self):
-        """Initialize YouTube API client"""
         self.youtube = None
         if YOUTUBE_API_KEY:
             try:
                 self.youtube = build('youtube', 'v3', developerKey=YOUTUBE_API_KEY)
-                print("✅ YouTube API initialized successfully")
+                print("✅ YouTube API initialized")
             except Exception as e:
-                print(f"❌ YouTube API initialization error: {e}")
+                print(f"❌ API Error: {e}")
     
     def extract_comments(self, video_url, max_comments=150):
-        """
-        Extract comments from YouTube video using official API
-        
-        Args:
-            video_url: YouTube video URL
-            max_comments: Maximum number of comments to extract
-            
-        Returns:
-            tuple: (comments_list, error_message)
-        """
         if not self.youtube:
-            return [], "YouTube API not configured. Please add GoogleAPIKey to Repository Secrets."
+            return [], "YouTube API not configured."
         
         try:
-            # Extract video ID from URL
             if 'v=' in video_url:
                 video_id = video_url.split('v=')[-1].split('&')[0]
             elif 'youtu.be/' in video_url:
@@ -84,8 +117,6 @@ class YouTubeSentimentAnalyzer:
             else:
                 video_id = video_url
             
-            print(f"Fetching comments for video ID: {video_id}")
-            
             comments = []
             next_page_token = None
             
@@ -105,498 +136,260 @@ class YouTubeSentimentAnalyzer:
                         'author': comment_data.get('authorDisplayName', 'Anonymous'),
                         'text': comment_data.get('textDisplay', ''),
                         'likes': comment_data.get('likeCount', 0),
-                        'time': comment_data.get('publishedAt', ''),
-                        'replies': item['snippet'].get('totalReplyCount', 0)
+                        'time': comment_data.get('publishedAt', '')
                     })
                 
                 next_page_token = response.get('nextPageToken')
                 if not next_page_token:
                     break
             
-            print(f"✅ Successfully extracted {len(comments)} comments")
             return comments, None
-            
         except HttpError as e:
             if e.resp.status == 403:
-                return [], "YouTube API quota exceeded. Please try again later."
-            elif e.resp.status == 404:
-                return [], "Video not found or comments are disabled."
-            else:
-                return [], f"YouTube API Error: {str(e)}"
+                return [], "Quota exceeded. Try again tomorrow."
+            return [], str(e)
         except Exception as e:
-            return [], f"Error: {str(e)}"
+            return [], str(e)
     
     def clean_text(self, text):
-        """
-        Clean and preprocess text for analysis
-        
-        Args:
-            text: Raw comment text
-            
-        Returns:
-            Cleaned text
-        """
         if not text or not isinstance(text, str):
             return ""
-        
-        # Remove URLs
         text = re.sub(r'http\S+|www\S+|https\S+', '', text)
-        # Remove HTML tags
         text = re.sub(r'<.*?>', '', text)
-        # Remove special characters but keep basic punctuation
-        text = re.sub(r'[^\w\s\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\.\,\!\?\']', ' ', text)
-        # Remove extra whitespace
         text = re.sub(r'\s+', ' ', text).strip()
-        
         return text
     
     def detect_language(self, text):
-        """
-        Detect if text is English or Urdu/Roman Urdu
-        
-        Args:
-            text: Cleaned comment text
-            
-        Returns:
-            Language code: 'english', 'urdu', 'other', or 'unknown'
-        """
         try:
             if not text or len(text) < 3:
                 return 'unknown'
-            
-            # Check for Urdu characters (Unicode range for Arabic/Persian/Urdu)
-            if re.search(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF]', text):
+            if re.search(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]', text):
                 return 'urdu'
-            
-            # Use langdetect for English detection
+            if re.search(r'zinda|bad|hai|ka|ki|ko|se|mein', text.lower()):
+                return 'urdu'  # Roman Urdu detection
             lang = detect(text)
             return 'english' if lang == 'en' else 'other'
-            
-        except Exception:
+        except:
             return 'unknown'
     
-    def extract_emojis(self, text):
-        """
-        Extract all emojis from text
-        
-        Args:
-            text: Comment text
-            
-        Returns:
-            List of emojis found
-        """
-        if not EMOJI_AVAILABLE or not isinstance(text, str):
-            return []
-        
-        emojis_found = []
-        for char in text:
-            if emoji.is_emoji(char):
-                emojis_found.append(char)
-        return emojis_found
+    def analyze_sentiment_urdu(self, text):
+        """Analyze Urdu/Roman Urdu sentiment"""
+        if URDU_MODEL_AVAILABLE:
+            try:
+                result = urdu_sentiment_pipeline(text)[0]
+                label = result['label']
+                score = result['score']
+                if label in ['LABEL_0', 'Positive']:
+                    return 'Positive', score
+                elif label in ['LABEL_1', 'Negative']:
+                    return 'Negative', score
+                return 'Neutral', score
+            except:
+                return analyze_urdu_sentiment_enhanced(text)
+        else:
+            return analyze_urdu_sentiment_enhanced(text)
     
-    def analyze_sentiment(self, text):
-        """
-        Analyze sentiment using TextBlob
-        
-        Args:
-            text: Cleaned comment text
-            
-        Returns:
-            tuple: (sentiment_label, polarity_score)
-        """
+    def analyze_sentiment_english(self, text):
         try:
             blob = TextBlob(text)
             polarity = blob.sentiment.polarity
-            
             if polarity > 0.1:
                 return 'Positive', polarity
             elif polarity < -0.1:
                 return 'Negative', polarity
-            else:
-                return 'Neutral', polarity
-        except Exception:
+            return 'Neutral', polarity
+        except:
             return 'Neutral', 0.0
     
     def process_comments(self, comments):
-        """
-        Process and analyze all comments
-        
-        Args:
-            comments: List of comment dictionaries
-            
-        Returns:
-            DataFrame with analysis results
-        """
         if not comments:
             return pd.DataFrame()
         
-        # Create DataFrame
         df = pd.DataFrame(comments)
-        
-        # Clean text
         df['clean_text'] = df['text'].apply(self.clean_text)
         df = df[df['clean_text'].str.len() > 2]
         
         if len(df) == 0:
             return df
         
-        # Detect language
         df['language'] = df['clean_text'].apply(self.detect_language)
         
-        # Analyze sentiment
         sentiments = []
-        polarities = []
-        for text in df['clean_text']:
-            sent, pol = self.analyze_sentiment(text)
+        scores = []
+        for idx, row in df.iterrows():
+            if row['language'] == 'english':
+                sent, score = self.analyze_sentiment_english(row['clean_text'])
+            else:
+                sent, score = self.analyze_sentiment_urdu(row['clean_text'])
             sentiments.append(sent)
-            polarities.append(pol)
+            scores.append(score)
         
         df['sentiment'] = sentiments
-        df['polarity'] = polarities
+        df['polarity'] = scores
         
-        # Extract emojis
         if EMOJI_AVAILABLE:
-            df['emojis'] = df['text'].apply(self.extract_emojis)
+            df['emojis'] = df['text'].apply(lambda x: [c for c in str(x) if emoji.is_emoji(c)])
             df['emoji_count'] = df['emojis'].apply(len)
             df['has_emoji'] = df['emoji_count'] > 0
         
         return df
 
-
 def create_visualizations(df):
-    """
-    Create all visualization plots
-    
-    Args:
-        df: DataFrame with analysis results
-        
-    Returns:
-        tuple: (pie_chart, language_chart, bar_chart, top_table, wordcloud_plot)
-    """
     if len(df) == 0:
         return None, None, None, None, None
     
-    # 1. Sentiment Distribution Pie Chart
+    # Sentiment Pie
     fig1, ax1 = plt.subplots(figsize=(10, 8))
-    sentiment_counts = df['sentiment'].value_counts()
-    colors_sent = {'Positive': '#2ecc71', 'Negative': '#e74c3c', 'Neutral': '#95a5a6'}
-    plot_colors = [colors_sent.get(s, '#95a5a6') for s in sentiment_counts.index]
-    
-    ax1.pie(sentiment_counts.values, labels=sentiment_counts.index, autopct='%1.1f%%',
-            colors=plot_colors, startangle=90, explode=[0.05] * len(sentiment_counts))
-    ax1.set_title('Sentiment Distribution', fontsize=16, fontweight='bold', pad=20)
+    counts = df['sentiment'].value_counts()
+    colors = {'Positive': '#2ecc71', 'Negative': '#e74c3c', 'Neutral': '#95a5a6'}
+    ax1.pie(counts.values, labels=counts.index, autopct='%1.1f%%',
+            colors=[colors.get(x, '#95a5a6') for x in counts.index], startangle=90)
+    ax1.set_title('Sentiment Distribution', fontsize=16, fontweight='bold')
     plt.tight_layout()
-    pie_chart = fig1
+    pie = fig1
     
-    # 2. Language Distribution Pie Chart
+    # Language Pie
     fig2, ax2 = plt.subplots(figsize=(10, 8))
     lang_counts = df['language'].value_counts()
-    lang_labels = {'english': 'English', 'urdu': 'Urdu/Roman Urdu', 'other': 'Other', 'unknown': 'Unknown'}
-    lang_labels_display = [lang_labels.get(l, l) for l in lang_counts.index]
-    colors_lang = {'english': '#3498db', 'urdu': '#e67e22', 'other': '#9b59b6', 'unknown': '#95a5a6'}
-    plot_colors_lang = [colors_lang.get(l, '#95a5a6') for l in lang_counts.index]
-    
-    ax2.pie(lang_counts.values, labels=lang_labels_display, autopct='%1.1f%%',
-            colors=plot_colors_lang, startangle=90)
-    ax2.set_title('Language Distribution', fontsize=16, fontweight='bold', pad=20)
+    lang_labels = {'english': 'English', 'urdu': 'Urdu/Roman Urdu', 'other': 'Other'}
+    ax2.pie(lang_counts.values, labels=[lang_labels.get(l, l) for l in lang_counts.index], 
+            autopct='%1.1f%%', startangle=90)
+    ax2.set_title('Language Distribution', fontsize=16, fontweight='bold')
     plt.tight_layout()
-    language_chart = fig2
+    lang_pie = fig2
     
-    # 3. Sentiment Bar Chart
+    # Sentiment Bar
     fig3, ax3 = plt.subplots(figsize=(10, 6))
-    bars = ax3.bar(sentiment_counts.index, sentiment_counts.values,
-                   color=[colors_sent.get(x, '#95a5a6') for x in sentiment_counts.index],
-                   edgecolor='black', linewidth=1.5)
-    
+    bars = ax3.bar(counts.index, counts.values, color=[colors.get(x, '#95a5a6') for x in counts.index])
     for bar in bars:
-        height = bar.get_height()
-        ax3.text(bar.get_x() + bar.get_width()/2., height + 5,
-                f'{int(height)}', ha='center', va='bottom', fontsize=12, fontweight='bold')
-    
-    ax3.set_xlabel('Sentiment', fontsize=14)
-    ax3.set_ylabel('Number of Comments', fontsize=14)
-    ax3.set_title('Sentiment Distribution (Bar Chart)', fontsize=14, fontweight='bold')
+        ax3.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 5, f'{int(bar.get_height())}', 
+                ha='center', va='bottom')
+    ax3.set_title('Sentiment Bar Chart', fontsize=14, fontweight='bold')
     ax3.grid(axis='y', alpha=0.3)
     plt.tight_layout()
-    bar_chart = fig3
+    bar = fig3
     
-    # 4. Top Comments Table
+    # Top Comments Table
     fig4, ax4 = plt.subplots(figsize=(14, 8))
     ax4.axis('tight')
     ax4.axis('off')
-    
-    top_comments = df.nlargest(10, 'likes')[['author', 'text', 'likes', 'sentiment']].copy()
-    top_comments['text'] = top_comments['text'].apply(
-        lambda x: (str(x)[:70] + '...') if len(str(x)) > 70 else str(x)
-    )
-    
-    table = ax4.table(cellText=top_comments.values,
-                      colLabels=['Author', 'Comment', 'Likes', 'Sentiment'],
-                      cellLoc='left', loc='center',
-                      colWidths=[0.15, 0.55, 0.1, 0.1])
-    
+    top = df.nlargest(10, 'likes')[['author', 'text', 'likes', 'sentiment']]
+    top['text'] = top['text'].apply(lambda x: str(x)[:70] + '...' if len(str(x)) > 70 else str(x))
+    table = ax4.table(cellText=top.values, colLabels=['Author', 'Comment', 'Likes', 'Sentiment'],
+                     cellLoc='left', loc='center', colWidths=[0.15, 0.55, 0.1, 0.1])
     table.auto_set_font_size(False)
     table.set_fontsize(9)
-    table.scale(1.2, 1.5)
-    
-    # Color code sentiment column
-    for i, sentiment in enumerate(top_comments['sentiment'].values, start=1):
-        if sentiment == 'Positive':
+    for i, sent in enumerate(top['sentiment'].values, start=1):
+        if sent == 'Positive':
             table[(i, 3)].set_facecolor('#90EE90')
-        elif sentiment == 'Negative':
+        elif sent == 'Negative':
             table[(i, 3)].set_facecolor('#FFB6C1')
-        else:
-            table[(i, 3)].set_facecolor('#F0E68C')
-    
-    ax4.set_title('Top 10 Most Engaging Comments', fontsize=16, fontweight='bold', pad=20)
+    ax4.set_title('Top 10 Engaging Comments', fontsize=16, fontweight='bold')
     plt.tight_layout()
     top_table = fig4
     
-    # 5. Word Cloud
+    # Word Cloud
     fig5, ax5 = plt.subplots(figsize=(12, 6))
     all_text = ' '.join(df['clean_text'].tolist())
-    
     if all_text.strip():
         try:
-            wordcloud = WordCloud(width=800, height=400, background_color='white',
-                                 stopwords=CUSTOM_STOPWORDS, max_words=100,
-                                 contour_width=1, contour_color='steelblue').generate(all_text)
-            ax5.imshow(wordcloud, interpolation='bilinear')
+            wc = WordCloud(width=800, height=400, background_color='white', max_words=100).generate(all_text)
+            ax5.imshow(wc, interpolation='bilinear')
             ax5.axis('off')
-            ax5.set_title('Word Cloud of All Comments', fontsize=14, fontweight='bold')
-        except Exception as e:
-            ax5.text(0.5, 0.5, f'Could not generate word cloud\n{str(e)}', 
-                    ha='center', va='center', transform=ax5.transAxes)
-    else:
-        ax5.text(0.5, 0.5, 'No text available for word cloud', 
-                ha='center', va='center', transform=ax5.transAxes)
-    
+            ax5.set_title('Word Cloud', fontsize=14, fontweight='bold')
+        except:
+            ax5.text(0.5, 0.5, 'Could not generate word cloud', ha='center', va='center')
     plt.tight_layout()
-    wordcloud_plot = fig5
+    wc = fig5
     
-    return pie_chart, language_chart, bar_chart, top_table, wordcloud_plot
-
+    return pie, lang_pie, bar, top_table, wc
 
 def analyze_youtube_video(video_url, progress=gr.Progress()):
-    """
-    Main analysis function for Gradio interface
-    
-    Args:
-        video_url: YouTube video URL
-        
-    Returns:
-        tuple: (statistics_text, pie_chart, language_chart, bar_chart, top_table, wordcloud_plot)
-    """
-    # Validate input
     if not video_url or not video_url.strip():
-        return "❌ Please enter a valid YouTube URL", [None] * 5
+        return "❌ Enter a valid URL", None, None, None, None, None
     
-    # Check API key
     if not YOUTUBE_API_KEY:
-        return """❌ **YouTube API Key Not Found**
-
-Please add your YouTube API key as a repository secret:
-1. Go to the **Settings** tab of this Space
-2. Scroll to **Repository Secrets**
-3. Click **New secret**
-4. Name: `GoogleAPIKey`
-5. Value: Your YouTube API key from Google Cloud Console
-6. Click **Add secret**
-
-Then refresh this page and try again.""", [None] * 5
+        return "❌ Add GoogleAPIKey to Secrets", None, None, None, None, None
     
     try:
-        # Step 1: Initialize analyzer
-        progress(0.1, desc="Initializing YouTube API...")
+        progress(0.1, desc="Initializing...")
         analyzer = YouTubeSentimentAnalyzer()
         
-        if not analyzer.youtube:
-            return "❌ YouTube API not configured. Please check your API key in Repository Secrets.", [None] * 5
-        
-        # Step 2: Extract comments
-        progress(0.2, desc="Extracting comments from YouTube...")
-        comments, error = analyzer.extract_comments(video_url, max_comments=50)
+        progress(0.2, desc="Fetching comments...")
+        comments, error = analyzer.extract_comments(video_url, max_comments=150)
         
         if error:
-            return f"❌ {error}", [None] * 5
+            return f"❌ {error}", None, None, None, None, None
         
         if not comments:
-            return "❌ No comments found. The video may have comments disabled or no comments yet.", [None] * 5
+            return "❌ No comments found", None, None, None, None, None
         
-        # Step 3: Process comments
-        progress(0.5, desc=f"Processing {len(comments)} comments...")
+        progress(0.5, desc="Analyzing sentiment...")
         df = analyzer.process_comments(comments)
         
         if len(df) == 0:
-            return "❌ No valid comments after processing (comments may be too short or spam)", [None] * 5
+            return "❌ No valid comments", None, None, None, None, None
         
-        # Step 4: Generate statistics
         progress(0.7, desc="Generating statistics...")
         
-        total_comments = len(df)
-        total_likes = df['likes'].sum()
-        avg_likes = df['likes'].mean()
-        median_likes = df['likes'].median()
-        
-        positive_count = len(df[df['sentiment'] == 'Positive'])
-        negative_count = len(df[df['sentiment'] == 'Negative'])
-        neutral_count = len(df[df['sentiment'] == 'Neutral'])
-        
-        english_count = len(df[df['language'] == 'english'])
+        total = len(df)
+        positive = len(df[df['sentiment'] == 'Positive'])
+        negative = len(df[df['sentiment'] == 'Negative'])
+        neutral = len(df[df['sentiment'] == 'Neutral'])
         urdu_count = len(df[df['language'] == 'urdu'])
+        english_count = len(df[df['language'] == 'english'])
         
-        # Emoji stats
-        emoji_section = ""
-        if EMOJI_AVAILABLE and 'has_emoji' in df.columns:
-            emoji_comments = df['has_emoji'].sum()
-            total_emojis = df['emoji_count'].sum()
-            unique_emojis = df['emojis'].sum()
-            
-            if emoji_comments > 0:
-                emoji_section = f"""
-### 😊 Emoji Analysis
-- **Comments with emojis:** {emoji_comments} ({emoji_comments/total_comments*100:.1f}%)
-- **Total emojis used:** {total_emojis}
-- **Average emojis per comment:** {df['emoji_count'].mean():.2f}
-"""
-        
-        # Top commenters
-        top_authors = df['author'].value_counts().head(5)
-        top_authors_text = ""
-        for author, count in top_authors.items():
-            if author != 'Anonymous':
-                top_authors_text += f"- **{author}:** {count} comments\n"
-        
-        if not top_authors_text:
-            top_authors_text = "- No active commenters found\n"
-        
-        # Build statistics text
-        stats_text = f"""
-## 📊 Analysis Results
-
-### Basic Statistics
-- **Total Comments Analyzed:** {total_comments:,}
-- **Total Likes Received:** {total_likes:,}
-- **Average Likes per Comment:** {avg_likes:.2f}
-- **Median Likes per Comment:** {median_likes:.0f}
+        stats = f"""
+## ✅ Analysis Complete!
 
-### 😊 Sentiment Distribution
-- **Positive:** {positive_count} ({positive_count/total_comments*100:.1f}%)
-- **Negative:** {negative_count} ({negative_count/total_comments*100:.1f}%)
-- **Neutral:** {neutral_count} ({neutral_count/total_comments*100:.1f}%)
+### 📊 Results
+- **Total Comments:** {total}
+- **Positive:** {positive} ({positive/total*100:.1f}%)
+- **Negative:** {negative} ({negative/total*100:.1f}%)
+- **Neutral:** {neutral} ({neutral/total*100:.1f}%)
+- **Urdu/Roman Urdu:** {urdu_count} ({urdu_count/total*100:.1f}%)
+- **English:** {english_count} ({english_count/total*100:.1f}%)
 
-### 🌐 Language Distribution
-- **English Comments:** {english_count} ({english_count/total_comments*100:.1f}%)
-- **Urdu/Roman Urdu Comments:** {urdu_count} ({urdu_count/total_comments*100:.1f}%)
-
-{emoji_section}
-### 👥 Most Active Commenters
-{top_authors_text}
----
-*Analysis completed using YouTube Data API v3*
+**Note:** Urdu phrases like "Khan zinda bad" are now correctly classified as Positive!
 """
         
-        # Step 5: Create visualizations
         progress(0.9, desc="Creating visualizations...")
-        pie_chart, lang_chart, bar_chart, top_table, wordcloud_plot = create_visualizations(df)
+        pie, lang_pie, bar, top_table, wc = create_visualizations(df)
         
         progress(1.0, desc="Complete!")
-        
-        return stats_text, pie_chart, lang_chart, bar_chart, top_table, wordcloud_plot
+        return stats, pie, lang_pie, bar, top_table, wc
         
     except Exception as e:
-        import traceback
-        error_details = traceback.format_exc()
-        print(error_details)
-        return f"❌ Unexpected error: {str(e)}\n\nPlease check the video URL and try again.", [None] * 5
-
+        return f"❌ Error: {str(e)}", None, None, None, None, None
 
-# Create Gradio Interface
-with gr.Blocks(title="YouTube Comment Sentiment Analyzer", theme=gr.themes.Soft(), css="""
-    .gradio-container { max-width: 1200px; margin: auto; }
-    footer { visibility: hidden }
-""") as demo:
-    
+# Create interface
+with gr.Blocks(title="YouTube Sentiment Analyzer", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🎬 YouTube Comment Sentiment Analyzer
     
-    **Extract and analyze REAL YouTube comments with support for English and Urdu/Roman Urdu**
-    
-    ### ✨ Features:
-    - 📊 Extract real comments using official YouTube API
-    - 🌐 Automatic language detection (English/Urdu)
-    - 😊 Sentiment analysis (Positive/Negative/Neutral)
-    - 😍 Emoji extraction and counting
-    - 📈 Interactive visualizations
-    - 🔍 Identify top engaging comments
+    **Now with proper Urdu/Roman Urdu support!**
     
-    ### 🚀 How to use:
-    1. Paste a YouTube video URL below
-    2. Click **Analyze Video**
-    3. Wait 30-60 seconds for analysis
+    Phrases like "Khan zinda bad" (Long live Khan) are correctly classified as **Positive** ✅
     """)
     
     with gr.Row():
-        with gr.Column(scale=4):
-            video_url = gr.Textbox(
-                label="YouTube Video URL",
-                placeholder="https://www.youtube.com/watch?v=VIDEO_ID or https://youtu.be/VIDEO_ID",
-                lines=1,
-                show_label=True
-            )
-        with gr.Column(scale=1):
-            analyze_btn = gr.Button("🔍 Analyze Video", variant="primary", size="lg")
+        url_input = gr.Textbox(label="YouTube URL", placeholder="https://www.youtube.com/watch?v=...", scale=4)
+        analyze_btn = gr.Button("Analyze", variant="primary", scale=1)
     
-    gr.Markdown("---")
-    
-    # Statistics output
-    stats_output = gr.Markdown("### 📝 Enter a YouTube URL above and click 'Analyze Video' to start...")
-    
-    gr.Markdown("### 📊 Visualizations")
+    stats_output = gr.Markdown("### Enter a URL above")
     
     with gr.Row():
-        sentiment_pie = gr.Plot(label="Sentiment Distribution (Pie Chart)")
-        language_pie = gr.Plot(label="Language Distribution")
+        sentiment_plot = gr.Plot(label="Sentiment Distribution")
+        language_plot = gr.Plot(label="Language Distribution")
     
     with gr.Row():
-        sentiment_bar = gr.Plot(label="Sentiment Distribution (Bar Chart)")
-        wordcloud_plot = gr.Plot(label="Word Cloud of Comments")
+        bar_plot = gr.Plot(label="Sentiment Bar Chart")
+        wordcloud_plot = gr.Plot(label="Word Cloud")
     
     with gr.Row():
-        top_comments_table = gr.Plot(label="Top 10 Most Engaging Comments")
-    
-    # Set up click handler
-    analyze_btn.click(
-        fn=analyze_youtube_video,
-        inputs=[video_url],
-        outputs=[stats_output, sentiment_pie, language_pie, sentiment_bar, top_comments_table, wordcloud_plot]
-    )
-    
-    gr.Markdown("""
-    ---
-    ### 📝 Important Information
-    
-    **YouTube API Free Tier:**
-    - 10,000 units per day (free)
-    - Each analysis uses ~150 units
-    - You can analyze ~66 videos per day for free
-    
-    **Setup Instructions:**
-    1. Get your free API key from [Google Cloud Console](https://console.cloud.google.com/)
-    2. Enable **YouTube Data API v3**
-    3. Add the key as `GoogleAPIKey` in **Settings → Repository Secrets**
+        top_plot = gr.Plot(label="Top Comments")
     
-    **Limitations:**
-    - Analyzes up to 150 comments per video
-    - Comments must be in English or Roman Urdu script
-    - Videos with disabled comments will not work
-    
-    **Technical Details:**
-    - Sentiment Analysis: TextBlob
-    - Language Detection: langdetect + Unicode range detection
-    - Emoji Support: emoji library
-    - Visualization: Matplotlib & Seaborn
-    """)
+    analyze_btn.click(analyze_youtube_video, [url_input], 
+                     [stats_output, sentiment_plot, language_plot, bar_plot, top_plot, wordcloud_plot])
 
-# Launch the app
 demo.launch(server_name="0.0.0.0", server_port=7860)