Update app.py

app.py

@@ -1,493 +1,401 @@
 import streamlit as st
-import pandas as pd
+from transformers import pipeline
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 import numpy as np
+import pandas as pd
 from datetime import datetime, timedelta
-import nltk
-from nltk.sentiment import SentimentIntensityAnalyzer
-from textblob import TextBlob
-from transformers import pipeline
+import plotly.express as px
+from sklearn.linear_model import Ridge
 from wordcloud import WordCloud
 import base64
 from io import BytesIO
-import plotly.express as px
+import nltk
+from textblob import TextBlob
 import praw
 from googleapiclient.discovery import build
-from sklearn.linear_model import Ridge
 import os
-import warnings
-
-# Suppress the ScriptRunContext warning
-warnings.filterwarnings("ignore", message="missing ScriptRunContext")
 
 # --------------------------
-# Initial Setup
+# Initial Setup & Configuration
 # --------------------------
 
-# Configure page
+# Set page config
 st.set_page_config(
-    page_title="SentimentSync Pro",
-    page_icon="📈",
-    layout="wide",
-    initial_sidebar_state="expanded"
+    page_title="🌟 SentimentSync: Live Sentiment Analysis Dashboard",
+    page_icon="📊",
+    layout="wide"
 )
 
 # --------------------------
-# Configuration
+# NLTK Data Download
 # --------------------------
 
-class Config:
-    # API Keys - Replace with your actual keys or use environment variables
-    YOUTUBE_API_KEY = os.getenv("YT_API_KEY", "AIzaSyDcUAkcoPvkTwN_tksmiW0dVPI5Bse7qos")
-    REDDIT_CLIENT_ID = os.getenv("REDDIT_CLIENT_ID", "your_reddit_client_id")
-    REDDIT_CLIENT_SECRET = os.getenv("REDDIT_CLIENT_SECRET", "your_reddit_secret")
-    REDDIT_USER_AGENT = "SentimentAnalysisBot/1.0"
-    
-    # NLTK data path
-    NLTK_DATA_PATH = os.path.join(os.path.expanduser("~"), "nltk_data")
-    
-    # Sentiment thresholds
-    POSITIVE_THRESHOLD = 0.1
-    NEGATIVE_THRESHOLD = -0.1
+def download_nltk_data():
+    try:
+        nltk_data_dir = os.path.join(os.path.expanduser("~"), "nltk_data")
+        if not os.path.exists(nltk_data_dir):
+            os.makedirs(nltk_data_dir)
+            
+        nltk.download('punkt', download_dir=nltk_data_dir)
+        nltk.download('stopwords', download_dir=nltk_data_dir)
+        nltk.download('punkt_tab', download_dir=nltk_data_dir)
+        nltk.data.path.append(nltk_data_dir)
+    except Exception as e:
+        st.error(f"Error downloading NLTK data: {str(e)}")
+        return False
+    return True
+
+if not download_nltk_data():
+    st.warning("Some NLTK features may not work properly without the required data files.")
 
 # --------------------------
-# Initialize Resources
+# Model Initialization
 # --------------------------
 
-def initialize_resources():
-    """Initialize all required resources with proper error handling"""
+@st.cache_resource
+def load_models():
     try:
-        # Setup NLTK data
-        os.makedirs(Config.NLTK_DATA_PATH, exist_ok=True)
-        nltk.data.path.append(Config.NLTK_DATA_PATH)
-        
-        required_nltk = ['punkt', 'stopwords', 'vader_lexicon']
-        for package in required_nltk:
-            try:
-                nltk.data.find(f'tokenizers/{package}')
-            except LookupError:
-                nltk.download(package, download_dir=Config.NLTK_DATA_PATH)
-    except Exception as e:
-        st.error(f"NLTK initialization failed: {str(e)}")
-        return False
-    
-    # Initialize sentiment analyzers
-    try:
-        st.session_state.vader = SentimentIntensityAnalyzer()
-        st.session_state.bert = pipeline(
+        # Initialize sentiment models
+        bert_sentiment = pipeline(
             "sentiment-analysis", 
             model="nlptown/bert-base-multilingual-uncased-sentiment"
         )
+        vader_analyzer = SentimentIntensityAnalyzer()
+        return bert_sentiment, vader_analyzer
     except Exception as e:
-        st.error(f"Model initialization failed: {str(e)}")
-        return False
-    
-    # Initialize API clients
+        st.error(f"Error loading models: {str(e)}")
+        return None, None
+
+bert_sentiment, vader_analyzer = load_models()
+
+if bert_sentiment is None or vader_analyzer is None:
+    st.stop()
+
+# --------------------------
+# API Clients Setup
+# --------------------------
+
+@st.cache_resource
+def setup_api_clients():
     try:
-        st.session_state.reddit = praw.Reddit(
-            client_id=Config.REDDIT_CLIENT_ID,
-            client_secret=Config.REDDIT_CLIENT_SECRET,
-            user_agent=Config.REDDIT_USER_AGENT
+        # Reddit API setup
+        reddit = praw.Reddit(
+            client_id="S7pTXhj5JDFGDb3-_zrJEA",
+            client_secret="QP3NYN4lrAKVLrBamzLGrpFywiVg8w",
+            user_agent="SoundaryaR_Bot/1.0"
         )
+        
+        youtube = build('youtube', 'v3', developerKey="AIzaSyDcUAkcoPvkTwN_tksmiW0dVPI5Bse7qos")
+        
+        return reddit, youtube
     except Exception as e:
-        st.error(f"Reddit client initialization failed: {str(e)}")
-        st.session_state.reddit = None
-    
-    try:
-        if Config.YOUTUBE_API_KEY.startswith("your_"):
-            st.session_state.youtube = None
-        else:
-            st.session_state.youtube = build(
-                'youtube', 
-                'v3', 
-                developerKey=Config.YOUTUBE_API_KEY,
-                cache_discovery=False
-            )
-    except Exception as e:
-        st.error(f"YouTube client initialization failed: {str(e)}")
-        st.session_state.youtube = None
-    
-    return True
+        st.error(f"Error setting up API clients: {str(e)}")
+        return None, None
+
+reddit, youtube = setup_api_clients()
+
+if reddit is None or youtube is None:
+    st.stop()
 
 # --------------------------
-# Core Functions
+# Helper Functions
 # --------------------------
 
-def analyze_sentiment(text):
-    """Analyze text using multiple sentiment models"""
-    results = {
-        'vader': 0,
-        'bert': 0,
-        'textblob': 0,
-        'bert_label': 'Error',
-        'bert_score': 0
+def bert_score(result):
+    """Convert BERT label to numerical score"""
+    label_map = {
+        '1 star': -1,
+        '2 stars': -0.5,
+        '3 stars': 0,
+        '4 stars': 0.5,
+        '5 stars': 1
     }
-    
+    return label_map.get(result['label'], 0)
+
+def analyze_text(text):
+    """Analyze sentiment using multiple models"""
     try:
-        # VADER
-        results['vader'] = st.session_state.vader.polarity_scores(text)['compound']
-        
-        # BERT (with truncation for long texts)
-        bert_result = st.session_state.bert(text[:512])[0]
-        results['bert_label'] = bert_result['label']
-        results['bert_score'] = bert_result['score']
-        
-        # Convert BERT label to numeric score
-        label_map = {
-            '1 star': -1,
-            '2 stars': -0.5,
-            '3 stars': 0,
-            '4 stars': 0.5,
-            '5 stars': 1
-        }
-        results['bert'] = label_map.get(bert_result['label'], 0)
-        
-        # TextBlob
-        results['textblob'] = TextBlob(text).sentiment.polarity
-        
+        vader_score = vader_analyzer.polarity_scores(text)['compound']
+        bert_result = bert_sentiment(text[:512])[0]  # Truncate to avoid token limits
+        bert_num = bert_score(bert_result)
+        textblob_score = TextBlob(text).sentiment.polarity
+        return vader_score, bert_num, textblob_score, bert_result
     except Exception as e:
-        st.error(f"Sentiment analysis error: {str(e)}")
-    
-    return results
+        st.error(f"Error analyzing text: {str(e)}")
+        return 0, 0, 0, {'label': 'Error', 'score': 0}
 
-def fetch_youtube_data(keyword, max_results=25):
-    """Fetch YouTube data with enhanced error handling"""
-    if st.session_state.youtube is None:
-        st.warning("YouTube API not configured")
-        return pd.DataFrame()
-    
+def generate_wordcloud(text):
+    """Generate word cloud image"""
     try:
-        # Search for videos
-        search_response = st.session_state.youtube.search().list(
-            q=keyword,
-            part="snippet",
-            maxResults=max_results,
-            type="video",
-            order="relevance",
-            safeSearch="moderate"
-        ).execute()
+        wordcloud = WordCloud(
+            width=800, 
+            height=400, 
+            background_color='white',
+            stopwords=nltk.corpus.stopwords.words('english')
+        ).generate(text)
         
-        # Get video details
-        video_ids = [item['id']['videoId'] for item in search_response['items']]
-        videos_response = st.session_state.youtube.videos().list(
-            part="snippet,statistics",
-            id=",".join(video_ids)
-        ).execute()
+        img = BytesIO()
+        wordcloud.to_image().save(img, format='PNG')
+        return base64.b64encode(img.getvalue()).decode()
+    except Exception as e:
+        st.error(f"Error generating word cloud: {str(e)}")
+        return ""
+
+# --------------------------
+# Data Fetching Functions
+# --------------------------
+
+@st.cache_data(ttl=3600)  # Cache for 1 hour
+def fetch_reddit_data(keyword, limit=50):
+    """Fetch Reddit posts containing the keyword"""
+    try:
+        subreddit = reddit.subreddit("all")
+        posts = subreddit.search(keyword, limit=limit)
         
-        # Process results
         data = []
-        for item in videos_response['items']:
-            snippet = item['snippet']
-            stats = item.get('statistics', {})
-            
+        for post in posts:
             data.append({
-                'source': 'YouTube',
-                'date': datetime.strptime(snippet['publishedAt'], '%Y-%m-%dT%H:%M:%SZ'),
-                'title': snippet['title'],
-                'text': f"{snippet['title']}\n{snippet['description']}",
-                'url': f"https://youtu.be/{item['id']}",
-                'views': int(stats.get('viewCount', 0)),
-                'likes': int(stats.get('likeCount', 0)),
-                'comments': int(stats.get('commentCount', 0)),
-                'thumbnail': snippet['thumbnails']['default']['url']
+                'date': datetime.fromtimestamp(post.created_utc),
+                'text': f"{post.title}\n{post.selftext}",
+                'source': 'Reddit',
+                'url': f"https://reddit.com{post.permalink}"
             })
-        
         return pd.DataFrame(data)
-    
     except Exception as e:
-        st.error(f"Error fetching YouTube data: {str(e)}")
+        st.error(f"Error fetching Reddit data: {str(e)}")
         return pd.DataFrame()
 
-def fetch_reddit_data(keyword, limit=50):
-    """Fetch Reddit posts with error handling"""
-    if st.session_state.reddit is None:
-        st.warning("Reddit API not configured")
-        return pd.DataFrame()
-    
+@st.cache_data(ttl=3600)  # Cache for 1 hour
+def fetch_youtube_data(keyword, limit=25):
+    """Fetch YouTube videos containing the keyword"""
     try:
-        posts = st.session_state.reddit.subreddit("all").search(
-            query=keyword,
-            limit=limit,
-            time_filter="month"
+        request = youtube.search().list(
+            q=keyword,
+            part="snippet",
+            maxResults=limit,
+            type="video",
+            order="relevance"
         )
+        response = request.execute()
         
         data = []
-        for post in posts:
+        for item in response['items']:
             data.append({
-                'source': 'Reddit',
-                'date': datetime.fromtimestamp(post.created_utc),
-                'title': post.title,
-                'text': f"{post.title}\n\n{post.selftext}",
-                'url': f"https://reddit.com{post.permalink}",
-                'upvotes': post.score,
-                'comments': post.num_comments,
-                'thumbnail': post.thumbnail if post.thumbnail not in ['self', 'default'] else None
+                'date': datetime.strptime(item['snippet']['publishedAt'], '%Y-%m-%dT%H:%M:%SZ'),
+                'text': f"{item['snippet']['title']}\n{item['snippet']['description']}",
+                'source': 'YouTube',
+                'url': f"https://youtube.com/watch?v={item['id']['videoId']}"
             })
-        
         return pd.DataFrame(data)
-    
     except Exception as e:
-        st.error(f"Error fetching Reddit data: {str(e)}")
+        st.error(f"Error fetching YouTube data: {str(e)}")
         return pd.DataFrame()
 
 # --------------------------
 # Visualization Functions
 # --------------------------
 
-def create_wordcloud(text):
-    """Generate a word cloud with proper error handling"""
+def plot_sentiment_trends(df, keyword):
+    """Plot sentiment trends over time"""
     try:
-        wc = WordCloud(
-            width=800,
-            height=400,
-            background_color='white',
-            stopwords=set(nltk.corpus.stopwords.words('english')),
-            collocations=False
-        ).generate(text)
-        
-        img = BytesIO()
-        wc.to_image().save(img, format='PNG')
-        return base64.b64encode(img.getvalue()).decode()
+        fig = px.line(
+            df, 
+            x='date', 
+            y=["VADER", "BERT", "TextBlob", "Average"],
+            title=f'Sentiment Over Time for "{keyword}"',
+            labels={'value': 'Sentiment Score', 'date': 'Date'},
+            color_discrete_map={
+                "VADER": "#636EFA",
+                "BERT": "#EF553B",
+                "TextBlob": "#00CC96",
+                "Average": "#AB63FA"
+            }
+        )
+        fig.update_layout(hovermode="x unified")
+        st.plotly_chart(fig, use_container_width=True)
     except Exception as e:
-        st.error(f"Word cloud error: {str(e)}")
-        return None
+        st.error(f"Error plotting sentiment trends: {str(e)}")
 
-def plot_sentiment_timeline(df):
-    """Interactive timeline plot of sentiment"""
+def plot_sentiment_distribution(df, keyword):
+    """Plot sentiment distribution"""
     try:
-        fig = px.line(
-            df,
-            x='date',
-            y='average_sentiment',
-            color='source',
-            title='Sentiment Over Time',
-            labels={'average_sentiment': 'Sentiment Score', 'date': 'Date'},
-            hover_data=['title', 'source', 'url'],
-            template='plotly_white'
+        dist_values = [
+            sum(df['Average'] > 0.1),  # Positive
+            sum(df['Average'] < -0.1),  # Negative
+            sum((df['Average'] >= -0.1) & (df['Average'] <= 0.1))  # Neutral
+        ]
+        
+        fig = px.pie(
+            values=dist_values, 
+            names=['Positive', 'Negative', 'Neutral'],
+            title=f'Sentiment Distribution for "{keyword}"',
+            color=['Positive', 'Negative', 'Neutral'],
+            color_discrete_map={
+                'Positive': '#00CC96',
+                'Negative': '#EF553B',
+                'Neutral': '#636EFA'
+            },
+            hole=0.3
         )
-        fig.update_traces(mode='markers+lines')
-        fig.update_layout(hovermode='x unified')
         st.plotly_chart(fig, use_container_width=True)
     except Exception as e:
-        st.error(f"Plotting error: {str(e)}")
+        st.error(f"Error plotting sentiment distribution: {str(e)}")
 
 # --------------------------
-# UI Components
+# Main App Interface
 # --------------------------
 
-def sidebar_controls():
-    """Render sidebar controls"""
+def main():
+    st.title("🌟 SentimentSync: Live Sentiment Analysis Dashboard")
+    
+    # Sidebar controls
     with st.sidebar:
-        st.title("🔧 Controls")
-        
+        st.header("🔍 Analysis Controls")
         analysis_mode = st.radio(
             "Analysis Mode",
-            ["Text Input", "Live Data"],
-            index=0,
-            key='analysis_mode'
+            ["Manual Text", "Live Data (Reddit & YouTube)"],
+            index=0
         )
         
-        if st.session_state.analysis_mode == "Text Input":
-            st.session_state.user_text = st.text_area(
-                "Enter your text:",
+        if analysis_mode == "Manual Text":
+            user_input = st.text_area(
+                "Enter text for sentiment analysis",
                 height=200,
-                placeholder="Type or paste text here..."
+                placeholder="Type or paste your text here..."
             )
+            analyze_btn = st.button("Analyze Text")
         else:
-            st.session_state.search_keyword = st.text_input(
-                "Search keyword:",
-                placeholder="e.g., Tesla, AI, etc."
-            )
-            
-            col1, col2 = st.columns(2)
-            st.session_state.use_reddit = col1.checkbox("Reddit", True)
-            st.session_state.use_youtube = col2.checkbox("YouTube", True)
-            
-            st.session_state.max_results = st.slider(
-                "Max results per source:",
-                10, 100, 25
+            keyword = st.text_input(
+                "Enter keyword for live data",
+                placeholder="e.g., Tesla, Bitcoin, etc."
             )
+            analyze_btn = st.button("Fetch & Analyze Data")
         
         st.markdown("---")
-        if st.button("Analyze", type="primary"):
-            st.session_state.analyze_clicked = True
-        if st.button("Reset"):
-            st.session_state.clear()
-            st.rerun()
-
-# --------------------------
-# Main App
-# --------------------------
-
-def main():
-    if not initialize_resources():
-        st.error("Critical initialization failed. Check error messages above.")
-        return
-    
-    st.title("📊 SentimentSync Pro")
-    st.caption("Advanced sentiment analysis across multiple platforms")
-    
-    sidebar_controls()
-    
-    if not hasattr(st.session_state, 'analyze_clicked') or not st.session_state.analyze_clicked:
-        st.info("Configure your analysis using the sidebar controls")
-        return
-    
-    # Perform analysis based on selected mode
-    if st.session_state.analysis_mode == "Text Input":
-        analyze_text_input()
-    else:
-        analyze_live_data()
-
-def analyze_text_input():
-    """Analyze manually entered text"""
-    if not st.session_state.user_text or len(st.session_state.user_text.strip()) < 10:
-        st.warning("Please enter at least 10 characters of text")
-        return
+        st.markdown("### Settings")
+        show_raw_data = st.checkbox("Show raw data", value=False)
+        st.markdown("---")
+        st.button("🔄 Reset Analysis")
     
-    with st.spinner("Analyzing text..."):
-        # Overall sentiment
-        sentiment = analyze_sentiment(st.session_state.user_text)
-        
-        # Display results
-        col1, col2, col3 = st.columns(3)
-        col1.metric("VADER Score", f"{sentiment['vader']:.2f}", 
-                   delta_color="inverse" if sentiment['vader'] < 0 else "normal")
-        col2.metric("BERT Sentiment", sentiment['bert_label'], f"{sentiment['bert_score']:.2f}")
-        col3.metric("TextBlob Score", f"{sentiment['textblob']:.2f}")
-        
-        # Word cloud
-        st.subheader("Word Cloud")
-        wc_img = create_wordcloud(st.session_state.user_text)
-        if wc_img:
-            st.image(f"data:image/png;base64,{wc_img}", use_container_width=True)
-        
-        # Sentence-level analysis
-        try:
-            sentences = nltk.sent_tokenize(st.session_state.user_text)
-            if len(sentences) > 1:
-                st.subheader("Sentence Breakdown")
+    # Main content area
+    if analyze_btn:
+        with st.spinner("Analyzing..."):
+            if analysis_mode == "Manual Text":
+                if not user_input or not any(c.isalpha() for c in user_input):
+                    st.warning("Please enter valid text for analysis")
+                    return
                 
-                sent_data = []
-                for i, sent in enumerate(sentences):
-                    sent_sentiment = analyze_sentiment(sent)
-                    sent_data.append({
-                        'Sentence': sent[:150] + ("..." if len(sent) > 150 else ""),
-                        'VADER': sent_sentiment['vader'],
-                        'BERT': sent_sentiment['bert'],
-                        'TextBlob': sent_sentiment['textblob'],
-                        'Average': np.mean([
-                            sent_sentiment['vader'],
-                            sent_sentiment['bert'],
-                            sent_sentiment['textblob']
-                        ])
-                    })
+                # Analyze the text
+                vader_score, bert_num, textblob_score, bert_result = analyze_text(user_input)
                 
-                sent_df = pd.DataFrame(sent_data)
+                # Display results
+                st.subheader("📊 Sentiment Analysis Results")
+                cols = st.columns(3)
+                cols[0].metric("VADER Score", f"{vader_score:.2f}", 
+                              "Positive" if vader_score > 0 else "Negative" if vader_score < 0 else "Neutral")
+                cols[1].metric("BERT Sentiment", bert_result['label'], f"Confidence: {bert_result['score']:.2f}")
+                cols[2].metric("TextBlob Polarity", f"{textblob_score:.2f}", 
+                              "Positive" if textblob_score > 0 else "Negative" if textblob_score < 0 else "Neutral")
                 
-                # Fixed dataframe display with proper parenthesis closure
-                styled_df = sent_df.style.background_gradient(
-                    cmap='RdYlGn',
-                    subset=['VADER', 'BERT', 'TextBlob', 'Average'],
-                    vmin=-1,
-                    vmax=1
-                )
-                st.dataframe(
-                styled_df,
-                use_container_width=True,
-                height=min(400, 35 * len(sent_df))
-            )
+                # Word cloud
+                st.subheader("📝 Word Cloud")
+                wordcloud_img = f'data:image/png;base64,{generate_wordcloud(user_input)}'
+                st.image(wordcloud_img, use_column_width=True)
                 
-        except Exception as e:
-            st.error(f"Sentence analysis error: {str(e)}")
-
-def analyze_live_data():
-    """Analyze live data from APIs"""
-    if not st.session_state.search_keyword:
-        st.warning("Please enter a search keyword")
-        return
-    
-    if not st.session_state.use_reddit and not st.session_state.use_youtube:
-        st.warning("Please select at least one data source")
-        return
-    
-    with st.spinner(f"Fetching data for '{st.session_state.search_keyword}'..."):
-        # Fetch data
-        dfs = []
-        
-        if st.session_state.use_reddit:
-            reddit_df = fetch_reddit_data(
-                st.session_state.search_keyword,
-                st.session_state.max_results
-            )
-            if not reddit_df.empty:
-                dfs.append(reddit_df)
-        
-        if st.session_state.use_youtube:
-            youtube_df = fetch_youtube_data(
-                st.session_state.search_keyword,
-                st.session_state.max_results
-            )
-            if not youtube_df.empty:
-                dfs.append(youtube_df)
-        
-        if not dfs:
-            st.error("No data found. Try different keywords or sources.")
-            return
-        
-        df = pd.concat(dfs, ignore_index=True)
-        
-        # Analyze sentiment
-        with st.spinner("Analyzing sentiment..."):
-            sentiment_results = []
-            for text in df['text']:
-                res = analyze_sentiment(text)
-                sentiment_results.append({
-                    'vader': res['vader'],
-                    'bert': res['bert'],
-                    'textblob': res['textblob'],
-                    'average_sentiment': np.mean([res['vader'], res['bert'], res['textblob']])
-                })
-            
-            sentiment_df = pd.DataFrame(sentiment_results)
-            df = pd.concat([df, sentiment_df], axis=1)
+                # Sentence-level analysis
+                try:
+                    sentences = nltk.sent_tokenize(user_input)
+                    if len(sentences) > 1:
+                        st.subheader("🔍 Sentence-level Analysis")
+                        dates = [datetime.now() - timedelta(minutes=len(sentences)-i) for i in range(len(sentences))]
+                        sentence_data = [analyze_text(s) for s in sentences]
+                        
+                        df = pd.DataFrame({
+                            "Sentence": sentences,
+                            "VADER": [d[0] for d in sentence_data],
+                            "BERT": [d[1] for d in sentence_data],
+                            "TextBlob": [d[2] for d in sentence_data]
+                        })
+                        df["Average"] = df[["VADER", "BERT", "TextBlob"]].mean(axis=1)
+                        
+                        st.dataframe(df.style.background_gradient(
+                            cmap='RdYlGn', 
+                            subset=["VADER", "BERT", "TextBlob", "Average"],
+                            vmin=-1, vmax=1
+                        ), use_container_width=True)
+                        
+                        plot_sentiment_trends(df, "Your Text")
+                except Exception as e:
+                    st.error(f"Error in sentence analysis: {str(e)}")
             
-            # Filter recent data
-            df = df[df['date'] >= (datetime.now() - timedelta(days=60))]
-            df = df.sort_values('date')
-            
-            # Calculate moving average
-            df['rolling_sentiment'] = df['average_sentiment'].rolling(
-                window=7,
-                min_periods=1
-            ).mean()
-    
-    # Display results
-    st.subheader(f"Results for: '{st.session_state.search_keyword}'")
-    
-    # Overall metrics
-    avg_sentiment = df['average_sentiment'].mean()
-    pos_pct = (df['average_sentiment'] > Config.POSITIVE_THRESHOLD).mean() * 100
-    neg_pct = (df['average_sentiment'] < Config.NEGATIVE_THRESHOLD).mean() * 100
-    
-    col1, col2, col3 = st.columns(3)
-    col1.metric("Average Sentiment", f"{avg_sentiment:.2f}")
-    col2.metric("Positive Content", f"{pos_pct:.1f}%")
-    col3.metric("Negative Content", f"{neg_pct:.1f}%")
-    
-    # Word cloud
-    st.subheader("Word Cloud")
-    combined_text = " ".join(df['text'])
-    wc_img = create_wordcloud(combined_text)
-    if wc_img:
-        st.image(f"data:image/png;base64,{wc_img}", use_container_width=True)
-    
-    # Timeline visualization
-    st.subheader("Sentiment Timeline")
-    plot_sentiment_timeline(df)
-    
-    # Raw data
-    with st.expander("View Raw Data"):
-        st.dataframe(df, use_container_width=True)
+            else:  # Live Data mode
+                if not keyword:
+                    st.warning("Please enter a keyword to search")
+                    return
+                
+                # Fetch data
+                with st.spinner(f"Fetching data for '{keyword}'..."):
+                    reddit_df = fetch_reddit_data(keyword)
+                    youtube_df = fetch_youtube_data(keyword)
+                    
+                    if reddit_df.empty and youtube_df.empty:
+                        st.error("No data found. Try a different keyword.")
+                        return
+                    
+                    df = pd.concat([reddit_df, youtube_df], ignore_index=True)
+                
+                # Analyze sentiment for each item
+                with st.spinner("Analyzing sentiment..."):
+                    results = []
+                    for _, row in df.iterrows():
+                        vader, bert, textblob, _ = analyze_text(row['text'])
+                        results.append((vader, bert, textblob))
+                    
+                    df['VADER'] = [r[0] for r in results]
+                    df['BERT'] = [r[1] for r in results]
+                    df['TextBlob'] = [r[2] for r in results]
+                    df['Average'] = df[['VADER', 'BERT', 'TextBlob']].mean(axis=1)
+                
+                # Display results
+                st.subheader(f"📊 Overall Sentiment for '{keyword}'")
+                
+                # Metrics
+                avg_sentiment = df['Average'].mean()
+                pos_pct = len(df[df['Average'] > 0.1]) / len(df) * 100
+                neg_pct = len(df[df['Average'] < -0.1]) / len(df) * 100
+                
+                cols = st.columns(3)
+                cols[0].metric("Average Sentiment", f"{avg_sentiment:.2f}", 
+                              "Positive" if avg_sentiment > 0 else "Negative" if avg_sentiment < 0 else "Neutral")
+                cols[1].metric("Positive Content", f"{pos_pct:.1f}%")
+                cols[2].metric("Negative Content", f"{neg_pct:.1f}%")
+                
+                # Word cloud
+                st.subheader("📝 Word Cloud")
+                combined_text = " ".join(df['text'])
+                wordcloud_img = f'data:image/png;base64,{generate_wordcloud(combined_text)}'
+                st.image(wordcloud_img, use_column_width=True)
+                
+                # Filter recent data (last 14 days)
+                df['date'] = pd.to_datetime(df['date'])
+                cutoff_date = datetime.now() - timedelta(days=14)
+                df_recent = df[df['date'] >= cutoff_date].sort_values('date')
+                
+                if not df_recent.empty:
+                    # Sentiment trends
+                    st.subheader("📅 Sentiment Trends (Last 14 Days)")
+                    plot_sentiment_trends(df_recent, keyword)
+                    
+                    # Sentiment distribution
+                    st.subheader("📊 Sentiment Distribution")
+                    plot_sentiment_distribution(df_recent, keyword)
+                    
+                    # Raw data (if enabled)
+                    if show_raw_data:
+                        st.subheader("📋 Raw Data")
+                        st.dataframe(df_recent[['date', 'source', 'text', 'Average']], use_container_width=True)
+                else:
+                    st.info("No recent data found (within last 14 days).")
 
 if __name__ == "__main__":
     main()