Update app.py

app.py

@@ -13,251 +13,390 @@ import nltk
 from textblob import TextBlob
 import praw
 from googleapiclient.discovery import build
+import os
 
-# Download NLTK data
-nltk.download('punkt')
-nltk.download('stopwords')
+# --------------------------
+# Initial Setup & Configuration
+# --------------------------
 
-# Initialize sentiment models
-bert_sentiment = pipeline("sentiment-analysis", model="nlptown/bert-base-multilingual-uncased-sentiment")
-vader_analyzer = SentimentIntensityAnalyzer()
-
-# Reddit API setup with your credentials
-REDDIT_CLIENT_ID = "S7pTXhj5JDFGDb3-_zrJEA"
-REDDIT_CLIENT_SECRET = "QP3NYN4lrAKVLrBamzLGrpFywiVg8w"
-REDDIT_USER_AGENT = "SoundaryaR_Bot/1.0"
-reddit = praw.Reddit(
-    client_id=REDDIT_CLIENT_ID,
-    client_secret=REDDIT_CLIENT_SECRET,
-    user_agent=REDDIT_USER_AGENT
+# Set page config
+st.set_page_config(
+    page_title="🌟 SentimentSync: Live Sentiment Analysis Dashboard",
+    page_icon="📊",
+    layout="wide"
 )
 
-# YouTube API setup with your API key
-YOUTUBE_API_KEY = "AIzaSyAChqXPaiNE9hKhApkgjgonzdgiCCOo"
-youtube = build('youtube', 'v3', developerKey=YOUTUBE_API_KEY)
+# --------------------------
+# NLTK Data Download
+# --------------------------
+
+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.")
+
+# --------------------------
+# Model Initialization
+# --------------------------
+
+@st.cache_resource
+def load_models():
+    try:
+        # 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"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:
+        # Reddit API setup
+        reddit = praw.Reddit(
+            client_id="S7pTXhj5JDFGDb3-_zrJEA",
+            client_secret="QP3NYN4lrAKVLrBamzLGrpFywiVg8w",
+            user_agent="SoundaryaR_Bot/1.0"
+        )
+        
+        # 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()
+
+if reddit is None or youtube is None:
+    st.stop()
+
+# --------------------------
+# Helper Functions
+# --------------------------
 
-# Helper function to convert BERT label to numerical score
 def bert_score(result):
-    label = result['label']
-    if label == '1 star': return -1
-    elif label == '2 stars': return -0.5
-    elif label == '3 stars': return 0
-    elif label == '4 stars': return 0.5
-    elif label == '5 stars': return 1
-    return 0
+    """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)
 
-# Analyze sentiment and return scores from all models
 def analyze_text(text):
-    vader_score = vader_analyzer.polarity_scores(text)['compound']
-    bert_result = bert_sentiment(text)[0]
-    bert_num = bert_score(bert_result)
-    textblob_score = TextBlob(text).sentiment.polarity
-    return vader_score, bert_num, textblob_score
+    """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}
 
-# Fetch live Reddit data
-@st.cache_data
-def fetch_reddit_data(keyword):
+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)
+        
+        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=100)
+        posts = subreddit.search(keyword, limit=limit)
+        
         data = []
         for post in posts:
             data.append({
                 'date': datetime.fromtimestamp(post.created_utc),
-                'text': post.title + " " + post.selftext,
-                'source': 'Reddit'
+                '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 Reddit data: {e}")
+        st.error(f"Error fetching Reddit data: {str(e)}")
         return pd.DataFrame()
 
-# Fetch live YouTube data
-@st.cache_data
-def fetch_youtube_data(keyword):
+@st.cache_data(ttl=3600)  # Cache for 1 hour
+def fetch_youtube_data(keyword, limit=25):
+    """Fetch YouTube videos containing the keyword"""
     try:
-        request = youtube.search().list(q=keyword, part="snippet", maxResults=50, type="video")
+        request = youtube.search().list(
+            q=keyword,
+            part="snippet",
+            maxResults=limit,
+            type="video",
+            order="relevance"
+        )
         response = request.execute()
+        
         data = []
         for item in response['items']:
-            title = item['snippet']['title']
-            description = item['snippet']['description']
-            published_at = datetime.strptime(item['snippet']['publishedAt'], '%Y-%m-%dT%H:%M:%SZ')
             data.append({
-                'date': published_at,
-                'text': title + " " + description,
-                'source': 'YouTube'
+                '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 YouTube data: {e}")
+        st.error(f"Error fetching YouTube data: {str(e)}")
         return pd.DataFrame()
 
-# Generate Word Cloud
-def generate_wordcloud(text):
-    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)
-    img = BytesIO()
-    wordcloud.to_image().save(img, format='PNG')
-    return base64.b64encode(img.getvalue()).decode()
-
-# Streamlit app setup
-st.title("🌟 SentimentSync: Live Sentiment Analysis Dashboard")
+# --------------------------
+# Visualization Functions
+# --------------------------
 
-# Sidebar for user input and keyword
-st.sidebar.header("🔍 Sentiment Analysis Controls")
-analysis_mode = st.sidebar.radio("Analysis Mode", ["Manual Text", "Live Data (Reddit & YouTube)"])
-if analysis_mode == "Manual Text":
-    user_input = st.sidebar.text_area("Enter text for sentiment analysis", height=200)
-else:
-    keyword = st.sidebar.text_input("Enter keyword for live data (e.g., 'Tesla')")
-
-# Display sentiment analysis results
-def display_sentiment_analysis(vader_score, bert_result, textblob_score, df=None):
-    st.subheader("📊 Sentiment Analysis Results")
-    st.write(f"**VADER Sentiment Score**: {vader_score:.2f}")
-    st.write(f"**BERT Sentiment**: {bert_result['label']} ({bert_result['score']:.2f})")
-    st.write(f"**TextBlob Sentiment Polarity**: {textblob_score:.2f}")
+def plot_sentiment_trends(df, keyword):
+    """Plot sentiment trends over time"""
+    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)
+    except Exception as e:
+        st.error(f"Error plotting sentiment trends: {str(e)}")
 
-    sentiment_data = {
-        'Positive': max(0, vader_score),
-        'Negative': min(0, vader_score),
-        'Neutral': 1 - abs(vader_score)
-    }
-    sentiment_df_overall = pd.DataFrame(list(sentiment_data.items()), columns=["Sentiment", "Score"])
-    st.bar_chart(sentiment_df_overall.set_index("Sentiment"))
+def plot_sentiment_distribution(df, keyword):
+    """Plot sentiment distribution"""
+    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
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    except Exception as e:
+        st.error(f"Error plotting sentiment distribution: {str(e)}")
 
-    if df is not None and not df.empty:
-        st.subheader("🔍 Detailed Sentiment Data")
-        st.write(df[['date', 'text', 'VADER', 'BERT', 'TextBlob', 'Average']])
+# --------------------------
+# Main App Interface
+# --------------------------
 
-# Process and analyze
-if st.sidebar.button("Analyze Sentiment"):
-    if analysis_mode == "Manual Text" and (not user_input or not any(c.isalpha() for c in user_input)):
-        st.warning("⚠️ Please enter text with at least one alphabetic character.")
-    elif analysis_mode == "Live Data (Reddit & YouTube)" and not keyword:
-        st.warning("⚠️ Please enter a keyword for live data analysis.")
-    else:
+def main():
+    st.title("🌟 SentimentSync: Live Sentiment Analysis Dashboard")
+    
+    # Sidebar controls
+    with st.sidebar:
+        st.header("🔍 Analysis Controls")
+        analysis_mode = st.radio(
+            "Analysis Mode",
+            ["Manual Text", "Live Data (Reddit & YouTube)"],
+            index=0
+        )
+        
+        if analysis_mode == "Manual Text":
+            user_input = st.text_area(
+                "Enter text for sentiment analysis",
+                height=200,
+                placeholder="Type or paste your text here..."
+            )
+            analyze_btn = st.button("Analyze Text")
+        else:
+            keyword = st.text_input(
+                "Enter keyword for live data",
+                placeholder="e.g., Tesla, Bitcoin, etc."
+            )
+            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")
+    
+    # Main content area
+    if analyze_btn:
         with st.spinner("Analyzing..."):
             if analysis_mode == "Manual Text":
-                # Overall sentiment for manual input
-                vader_score, bert_num, textblob_score = analyze_text(user_input)
-                bert_result = bert_sentiment(user_input)[0]
+                if not user_input or not any(c.isalpha() for c in user_input):
+                    st.warning("Please enter valid text for analysis")
+                    return
                 
-                # Sentence-level analysis
-                sentences = nltk.sent_tokenize(user_input)
-                if len(sentences) > 1:
-                    dates = [datetime.today() - timedelta(days=len(sentences) - 1 - i) for i in range(len(sentences))]
-                    sentence_data = [analyze_text(s) for s in sentences]
-                    df = pd.DataFrame({
-                        "date": dates,
-                        "text": 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)
-                else:
-                    df = pd.DataFrame()
-
-                display_sentiment_analysis(vader_score, bert_result, textblob_score, df)
+                # 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")
+                
+                # 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, caption="Word Cloud of Input Text")
-
-            elif analysis_mode == "Live Data (Reddit & YouTube)":
-                # Fetch live data with your credentials
-                reddit_df = fetch_reddit_data(keyword)
-                youtube_df = fetch_youtube_data(keyword)
-                df = pd.concat([reddit_df, youtube_df], ignore_index=True)
-
-                if not df.empty:
-                    # Analyze sentiment for each post
-                    sentiment_data = [analyze_text(row['text']) for _, row in df.iterrows()]
-                    df['VADER'] = [d[0] for d in sentiment_data]
-                    df['BERT'] = [d[1] for d in sentiment_data]
-                    df['TextBlob'] = [d[2] for d in sentiment_data]
-                    df['Average'] = df[['VADER', 'BERT', 'TextBlob']].mean(axis=1)
-
-                    # Overall sentiment for all fetched data
-                    combined_text = " ".join(df['text'])
-                    vader_score, bert_num, textblob_score = analyze_text(combined_text)
-                    bert_result = bert_sentiment(combined_text)[0]
-                    display_sentiment_analysis(vader_score, bert_result, textblob_score, df)
-
-                    # Word cloud
-                    wordcloud_img = f'data:image/png;base64,{generate_wordcloud(combined_text)}'
-                    st.image(wordcloud_img, use_column_width=True, caption=f"Word Cloud for '{keyword}'")
-
-                    # Dynamic 14-day filter based on current date
-                    df['date'] = pd.to_datetime(df['date'])
-                    current_date = datetime.today()
-                    cutoff_date = current_date - timedelta(days=14)
-                    df_recent = df[df['date'] >= cutoff_date].sort_values('date')
-
-                    # Past sentiment trends
-                    if not df_recent.empty:
-                        st.subheader("📅 Past Sentiment Trends (Last 14 Days)")
-                        fig1 = px.line(df_recent, x='date', y=["VADER", "BERT", "TextBlob", "Average"],
-                                      title=f'Sentiment Over Time for "{keyword}" (Last 14 Days from {current_date.date()})', 
-                                      markers=True, line_shape='spline')
-                        st.plotly_chart(fig1)
-
-                        # Sentiment prediction with Ridge Regression
-                        st.subheader("🔮 Sentiment Prediction for Next 7 Days")
-                        X = np.array((df_recent['date'] - df_recent['date'].min()).dt.total_seconds() / 86400).reshape(-1, 1)
-                        future_dates = [current_date + timedelta(days=i) for i in range(1, 8)]
-                        X_future = np.array(range(int(X[-1]) + 1, int(X[-1]) + 8)).reshape(-1, 1)
-
-                        models = {
-                            "VADER": Ridge(alpha=1.0).fit(X, df_recent["VADER"]),
-                            "BERT": Ridge(alpha=1.0).fit(X, df_recent["BERT"]),
-                            "TextBlob": Ridge(alpha=1.0).fit(X, df_recent["TextBlob"]),
-                            "Average": Ridge(alpha=1.0).fit(X, df_recent["Average"])
-                        }
-                        predictions = {name: model.predict(X_future) for name, model in models.items()}
-                        future_df = pd.DataFrame({
-                            "Date": future_dates,
-                            "VADER": predictions["VADER"],
-                            "BERT": predictions["BERT"],
-                            "TextBlob": predictions["TextBlob"],
-                            "Average": predictions["Average"]
+                st.image(wordcloud_img, use_column_width=True)
+                
+                # 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]
                         })
-                        fig2 = px.line(future_df, x='Date', y=["VADER", "BERT", "TextBlob", "Average"],
-                                      title=f'Predicted Sentiment Trend for "{keyword}" (Next 7 Days from {current_date.date()})', 
-                                      markers=True, line_shape='spline')
-                        st.plotly_chart(fig2)
-
-                        # Sentiment distribution
-                        st.subheader("📊 Sentiment Distribution")
-                        dist_values = [
-                            sum(df_recent['Average'] > 0),
-                            sum(df_recent['Average'] < 0),
-                            sum(df_recent['Average'] == 0)
-                        ]
-                        fig3 = px.pie(values=dist_values, names=['Positive', 'Negative', 'Neutral'],
-                                     title=f'Sentiment Distribution for "{keyword}" (Last 14 Days)', hole=0.3)
-                        st.plotly_chart(fig3)
-
-                        # Sentiment scatter plot (corrected line)
-                        st.subheader("🔎 Sentiment Scatter Plot")
-                        fig4 = px.scatter(df_recent, x='date', y="Average", 
-                                         title=f'Sentiment Over Time for "{keyword}" (Last 14 Days)',
-                                         text=df_recent["text"].str[:20] + "...", color="source")
-                        fig4.update_traces(textposition='top center')
-                        st.plotly_chart(fig4)  # Fixed syntax error here
-
-                        # Rolling average
-                        st.subheader("📈 Rolling Average Sentiment")
-                        df_recent = df_recent.sort_values('date')
-                        df_recent['Rolling Avg'] = df_recent['Average'].rolling(window=min(7, len(df_recent)), min_periods=1).mean()
-                        fig5 = px.line(df_recent, x='date', y='Rolling Avg',
-                                      title=f"Rolling Average Sentiment for '{keyword}' (Last 14 Days, Window: {min(7, len(df_recent))})", 
-                                      markers=True)
-                        st.plotly_chart(fig5)
-                    else:
-                        st.info(f"No data within the last 14 days (from {cutoff_date.date()} to {current_date.date()}) for this keyword.")
+                        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)}")
+            
+            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.error("No data fetched. Check API credentials or keyword.")
+                    st.info("No recent data found (within last 14 days).")
 
-# Reset button
-if st.sidebar.button('🔄 Reset Analysis'):
-    st.experimental_rerun()
+if __name__ == "__main__":
+    main()