Update app.py

app.py

@@ -1,402 +1,493 @@
 import streamlit as st
-from transformers import pipeline
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-import numpy as np
 import pandas as pd
+import numpy as np
 from datetime import datetime, timedelta
+import nltk
+import os
+from io import BytesIO
+import base64
 import plotly.express as px
-from sklearn.linear_model import Ridge
 from wordcloud import WordCloud
-import base64
-from io import BytesIO
-import nltk
 from textblob import TextBlob
-import praw
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+from transformers import pipeline
 from googleapiclient.discovery import build
-import os
+from googleapiclient.errors import HttpError
+import praw
+from sklearn.linear_model import Ridge
 
 # --------------------------
-# Initial Setup & Configuration
+# Initial Setup
 # --------------------------
 
-# Set page config
+# Configure page
 st.set_page_config(
-    page_title="🌟 SentimentSync: Live Sentiment Analysis Dashboard",
-    page_icon="📊",
-    layout="wide"
+    page_title="SentimentSync Pro",
+    page_icon="📈",
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
 # --------------------------
-# NLTK Data Download
+# Configuration
 # --------------------------
 
-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.")
+class Config:
+    # Replace these with your actual API keys or use environment variables
+    YOUTUBE_API_KEY = os.getenv("YT_API_KEY", "your_youtube_api_key_here")
+    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
 
 # --------------------------
-# Model Initialization
+# Initialize Resources
 # --------------------------
 
-@st.cache_resource
-def load_models():
+def initialize_resources():
+    """Initialize all required resources with proper error handling"""
+    
+    # Setup NLTK
+    try:
+        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:
-        # Initialize sentiment models
-        bert_sentiment = pipeline(
+        st.session_state.vader = SentimentIntensityAnalyzer()
+        st.session_state.bert = 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"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():
+        st.error(f"Model initialization failed: {str(e)}")
+        return False
+    
+    # Initialize API clients
     try:
-        # Reddit API setup
-        reddit = praw.Reddit(
-            client_id="S7pTXhj5JDFGDb3-_zrJEA",
-            client_secret="QP3NYN4lrAKVLrBamzLGrpFywiVg8w",
-            user_agent="SoundaryaR_Bot/1.0"
+        st.session_state.reddit = praw.Reddit(
+            client_id=Config.REDDIT_CLIENT_ID,
+            client_secret=Config.REDDIT_CLIENT_SECRET,
+            user_agent=Config.REDDIT_USER_AGENT
         )
-        
-        # YouTube API setup
-        youtube = build('youtube', 'v3', developerKey="AIzaSyAChqXPaiNE9hKhApkgjgonzdgiCCOo")
-        
-        return reddit, youtube
     except Exception as e:
-        st.error(f"Error setting up API clients: {str(e)}")
-        return None, None
-
-reddit, youtube = setup_api_clients()
+        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
 
-if reddit is None or youtube is None:
+if not initialize_resources():
+    st.error("Critical initialization failed. Check error messages above.")
     st.stop()
 
 # --------------------------
-# Helper Functions
+# Core Functions
 # --------------------------
 
-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
+def analyze_sentiment(text):
+    """Analyze text using multiple sentiment models"""
+    results = {
+        'vader': 0,
+        'bert': 0,
+        'textblob': 0,
+        'bert_label': 'Error',
+        'bert_score': 0
     }
-    return label_map.get(result['label'], 0)
-
-def analyze_text(text):
-    """Analyze sentiment using multiple models"""
-    try:
-        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"Error analyzing text: {str(e)}")
-        return 0, 0, 0, {'label': 'Error', 'score': 0}
-
-def generate_wordcloud(text):
-    """Generate word cloud image"""
+    
     try:
-        wordcloud = WordCloud(
-            width=800, 
-            height=400, 
-            background_color='white',
-            stopwords=nltk.corpus.stopwords.words('english')
-        ).generate(text)
+        # 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
         
-        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.error(f"Sentiment analysis error: {str(e)}")
+    
+    return results
 
-@st.cache_data(ttl=3600)  # Cache for 1 hour
-def fetch_reddit_data(keyword, limit=50):
-    """Fetch Reddit posts containing the keyword"""
+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()
+    
     try:
-        subreddit = reddit.subreddit("all")
-        posts = subreddit.search(keyword, limit=limit)
+        # 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()
         
+        # 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()
+        
+        # Process results
         data = []
-        for post in posts:
+        for item in videos_response['items']:
+            snippet = item['snippet']
+            stats = item.get('statistics', {})
+            
             data.append({
-                'date': datetime.fromtimestamp(post.created_utc),
-                'text': f"{post.title}\n{post.selftext}",
-                'source': 'Reddit',
-                'url': f"https://reddit.com{post.permalink}"
+                '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']
             })
+        
         return pd.DataFrame(data)
+    
+    except HttpError as e:
+        if e.resp.status == 403:
+            st.error("YouTube API quota exceeded. Try again later.")
+        else:
+            st.error(f"YouTube API error: {str(e)}")
+        return pd.DataFrame()
+    
     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()
 
-@st.cache_data(ttl=3600)  # Cache for 1 hour
-def fetch_youtube_data(keyword, limit=25):
-    """Fetch YouTube videos containing the keyword"""
+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()
+    
     try:
-        request = youtube.search().list(
-            q=keyword,
-            part="snippet",
-            maxResults=limit,
-            type="video",
-            order="relevance"
+        posts = st.session_state.reddit.subreddit("all").search(
+            query=keyword,
+            limit=limit,
+            time_filter="month"
         )
-        response = request.execute()
         
         data = []
-        for item in response['items']:
+        for post in posts:
             data.append({
-                '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']}"
+                '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
             })
+        
         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()
 
 # --------------------------
 # Visualization Functions
 # --------------------------
 
-def plot_sentiment_trends(df, keyword):
-    """Plot sentiment trends over time"""
+def create_wordcloud(text):
+    """Generate a word cloud with proper error handling"""
     try:
-        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)
+        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()
     except Exception as e:
-        st.error(f"Error plotting sentiment trends: {str(e)}")
+        st.error(f"Word cloud error: {str(e)}")
+        return None
 
-def plot_sentiment_distribution(df, keyword):
-    """Plot sentiment distribution"""
+def plot_sentiment_timeline(df):
+    """Interactive timeline plot of sentiment"""
     try:
-        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 = 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'
         )
+        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"Error plotting sentiment distribution: {str(e)}")
+        st.error(f"Plotting error: {str(e)}")
 
 # --------------------------
-# Main App Interface
+# UI Components
 # --------------------------
 
-def main():
-    st.title("🌟 SentimentSync: Live Sentiment Analysis Dashboard")
-    
-    # Sidebar controls
+def sidebar_controls():
+    """Render sidebar controls"""
     with st.sidebar:
-        st.header("🔍 Analysis Controls")
+        st.title("🔧 Controls")
+        
         analysis_mode = st.radio(
             "Analysis Mode",
-            ["Manual Text", "Live Data (Reddit & YouTube)"],
-            index=0
+            ["Text Input", "Live Data"],
+            index=0,
+            key='analysis_mode'
         )
         
-        if analysis_mode == "Manual Text":
-            user_input = st.text_area(
-                "Enter text for sentiment analysis",
+        if st.session_state.analysis_mode == "Text Input":
+            st.session_state.user_text = st.text_area(
+                "Enter your text:",
                 height=200,
-                placeholder="Type or paste your text here..."
+                placeholder="Type or paste text here..."
             )
-            analyze_btn = st.button("Analyze Text")
         else:
-            keyword = st.text_input(
-                "Enter keyword for live data",
-                placeholder="e.g., Tesla, Bitcoin, etc."
+            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
             )
-            analyze_btn = st.button("Fetch & Analyze Data")
         
         st.markdown("---")
-        st.markdown("### Settings")
-        show_raw_data = st.checkbox("Show raw data", value=False)
-        st.markdown("---")
-        st.button("🔄 Reset Analysis")
+        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():
+    st.title("📊 SentimentSync Pro")
+    st.caption("Advanced sentiment analysis across multiple platforms")
     
-    # 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
-                
-                # Analyze the text
-                vader_score, bert_num, textblob_score, bert_result = analyze_text(user_input)
-                
-                # 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")
+    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
+    
+    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")
                 
-                # 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)
+                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']
+                        ])
+                    })
                 
-                # 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)}")
+                sent_df = pd.DataFrame(sent_data)
+                st.dataframe(
+                    sent_df.style.background_gradient(
+                        cmap='RdYlGn',
+                        subset=['VADER', 'BERT', 'TextBlob', 'Average'],
+                        vmin=-1, 
+                        vmax=1
+                    ),
+                    use_container_width=True,
+                    height=min(400, 35 * len(sent_df))
+        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']])
+                })
             
-            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).")
+            sentiment_df = pd.DataFrame(sentiment_results)
+            df = pd.concat([df, sentiment_df], axis=1)
+            
+            # 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)
 
 if __name__ == "__main__":
     main()