Update app.py

app.py

@@ -9,218 +9,284 @@ import requests
 from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
 import torch
 
-st.set_page_config(page_title="Stock News Sentiment Analyzer", layout="wide")
+# Page config
+st.set_page_config(
+    page_title="Stock News Sentiment Analyzer",
+    page_icon="📈",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for styling
+st.markdown("""
+    <style>
+    .stAlert {
+        padding: 10px;
+        margin-bottom: 20px;
+    }
+    .reportview-container {
+        background: #f0f2f6
+    }
+    .main {
+        padding: 2rem;
+    }
+    h1, h2, h3 {
+        color: #1f77b4;
+    }
+    </style>
+""", unsafe_allow_html=True)
 
 # Initialize FinBERT-tone model and tokenizer
 @st.cache_resource
-def load_model():
-    model = AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone")
-    tokenizer = AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone")
-    return pipeline("text-classification", model=model, tokenizer=tokenizer)
+def load_finbert_model():
+    try:
+        model = AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone")
+        tokenizer = AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone")
+        return pipeline("text-classification", model=model, tokenizer=tokenizer)
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        return None
 
-finbert = load_model()
+# Load the model
+finbert = load_finbert_model()
 
+# Web scraping functions
 def verify_link(url, timeout=10, retries=3):
+    """Verify if a URL is accessible."""
     for _ in range(retries):
         try:
             response = requests.head(url, timeout=timeout, allow_redirects=True)
-            if 200 <= response.status_code < 300:
-                return True
+            return 200 <= response.status_code < 300
         except requests.RequestException:
             continue
     return False
 
 def get_news(ticker):
-    finviz_url = 'https://finviz.com/quote.ashx?t='
-    url = finviz_url + ticker
-    req = Request(url=url, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:20.0) Gecko/20100101 Firefox/20.0'}) 
-    response = urlopen(req)    
-    html = BeautifulSoup(response, 'html.parser')
-    news_table = html.find(id='news-table')
-    return news_table
+    """Scrape news from FinViz for a given stock ticker."""
+    try:
+        finviz_url = f'https://finviz.com/quote.ashx?t={ticker}'
+        req = Request(url=finviz_url, headers={
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        })
+        response = urlopen(req)    
+        html = BeautifulSoup(response, 'html.parser')
+        news_table = html.find(id='news-table')
+        if news_table is None:
+            raise ValueError("No news table found - invalid ticker or website structure changed")
+        return news_table
+    except Exception as e:
+        raise Exception(f"Error fetching news for {ticker}: {str(e)}")
 
 def parse_news(news_table):
+    """Parse the news table and return a DataFrame."""
     parsed_news = []
     
-    for x in news_table.findAll('tr'):
-        try:
-            text = x.a.get_text()
-            link = x.a['href']
-            date_scrape = x.td.text.strip().split()
+    try:
+        for row in news_table.findAll('tr'):
+            title = row.a.get_text()
+            link = row.a['href']
+            date_data = row.td.text.strip().split()
             
-            if len(date_scrape) == 1:
+            if len(date_data) == 1:
+                time = date_data[0]
                 date = datetime.datetime.today().strftime('%Y-%m-%d')
-                time = date_scrape[0]
             else:
-                date = date_scrape[0]
-                time = date_scrape[1]
-
-            datetime_str = f"{date} {time}"
-            datetime_parsed = parser.parse(datetime_str)
-
-            is_valid = verify_link(link)
+                date = date_data[0]
+                time = date_data[1]
             
-            parsed_news.append([datetime_parsed, text, link, is_valid])
+            parsed_date = parser.parse(f"{date} {time}")
+            is_valid = verify_link(link)
             
-        except Exception as e:
-            print("Error parsing news:", e)
-            continue
-    
-    columns = ['datetime', 'headline', 'link', 'is_valid']
-    parsed_news_df = pd.DataFrame(parsed_news, columns=columns)
-    
-    return parsed_news_df
+            parsed_news.append([parsed_date, title, link, is_valid])
+        
+        return pd.DataFrame(parsed_news, columns=['datetime', 'headline', 'link', 'is_valid'])
+    except Exception as e:
+        raise Exception(f"Error parsing news: {str(e)}")
 
-def score_news(parsed_news_df):
-    # Get FinBERT-tone predictions
-    predictions = finbert(parsed_news_df['headline'].tolist())
-    
-    # Convert predictions to sentiment scores and collect all data
-    sentiment_data = []
-    for pred in predictions:
-        label = pred['label']
-        score = pred['score']
+def analyze_sentiment(text):
+    """Analyze sentiment of a single piece of text using FinBERT-tone."""
+    try:
+        result = finbert(text)[0]
+        label = result['label']
+        score = result['score']
         
-        # Convert to -1 to 1 scale
-        if label == 'Positive':
-            sentiment_score = score
-        elif label == 'Negative':
-            sentiment_score = -score
-        else:  # Neutral
-            sentiment_score = 0
-            
-        sentiment_data.append({
+        sentiment_score = {
+            'Positive': score,
+            'Negative': -score,
+            'Neutral': 0
+        }.get(label, 0)
+        
+        return {
             'sentiment_score': sentiment_score,
             'tone': label,
             'confidence': score
-        })
-    
-    # Convert to DataFrame
-    scores_df = pd.DataFrame(sentiment_data)
-    
-    # Join with original news DataFrame
-    parsed_and_scored_news = parsed_news_df.join(scores_df)
-    parsed_and_scored_news = parsed_and_scored_news.set_index('datetime')
-    
-    return parsed_and_scored_news
-
-def plot_hourly_sentiment(parsed_and_scored_news, ticker):
-    mean_scores = parsed_and_scored_news['sentiment_score'].resample('h').mean()
-    
-    fig = px.bar(mean_scores, x=mean_scores.index, y='sentiment_score', 
-                 title=f'{ticker} Hourly Sentiment Scores',
-                 color='sentiment_score',
-                 color_continuous_scale=['red', 'yellow', 'green'],
-                 range_color=[-1, 1])
-    
-    fig.update_layout(coloraxis_colorbar=dict(
-        title="Sentiment",
-        tickvals=[-1, 0, 1],
-        ticktext=["Negative", "Neutral", "Positive"],
-    ))
-    
-    return fig
+        }
+    except Exception as e:
+        st.error(f"Error analyzing sentiment: {str(e)}")
+        return {'sentiment_score': 0, 'tone': 'Error', 'confidence': 0}
 
-def plot_sentiment_distribution(parsed_and_scored_news, ticker):
-    tone_counts = parsed_and_scored_news['tone'].value_counts()
-    
-    fig = px.pie(values=tone_counts.values, 
-                 names=tone_counts.index,
-                 title=f'{ticker} News Sentiment Distribution',
-                 color=tone_counts.index,
-                 color_discrete_map={'Positive': 'green',
-                                   'Neutral': 'yellow',
-                                   'Negative': 'red'})
-    
-    return fig
-
-def get_recommendation(sentiment_scores):
-    avg_sentiment = sentiment_scores['sentiment_score'].mean()
-    tone_counts = sentiment_scores['tone'].value_counts()
-    total_articles = len(sentiment_scores)
-    
-    # Calculate percentages
-    positive_pct = tone_counts.get('Positive', 0) / total_articles * 100
-    negative_pct = tone_counts.get('Negative', 0) / total_articles * 100
-    
-    if avg_sentiment >= 0.3 and positive_pct >= 50:
-        return f"Strong Positive Sentiment (Score: {avg_sentiment:.2f}, {positive_pct:.1f}% positive news). The recent news suggests a very favorable outlook for this stock. Consider buying or holding if you already own it."
-    elif avg_sentiment >= 0.1:
-        return f"Moderately Positive Sentiment (Score: {avg_sentiment:.2f}, {positive_pct:.1f}% positive news). The recent news leans positive. Consider holding if you own the stock."
-    elif avg_sentiment <= -0.3 and negative_pct >= 50:
-        return f"Strong Negative Sentiment (Score: {avg_sentiment:.2f}, {negative_pct:.1f}% negative news). The recent news suggests significant caution. Consider selling or avoiding this stock for now."
-    elif avg_sentiment <= -0.1:
-        return f"Moderately Negative Sentiment (Score: {avg_sentiment:.2f}, {negative_pct:.1f}% negative news). The recent news leans negative. Consider reducing exposure or waiting for better entry points."
-    else:
-        return f"Neutral Sentiment (Score: {avg_sentiment:.2f}). The recent news shows mixed or neutral signals. Consider holding current positions and monitoring for clearer trends."
-
-st.header("Stock News Sentiment Analyzer (FinBERT-tone)")
-
-ticker = st.text_input('Enter Stock Ticker', '').upper()
-
-try:
-    if ticker:
-        st.subheader(f"Sentiment Analysis and Recommendation for {ticker} Stock")
-        news_table = get_news(ticker)
-        parsed_news_df = parse_news(news_table)
-        parsed_and_scored_news = score_news(parsed_news_df)
+def process_news_sentiment(parsed_news_df):
+    """Process sentiment for all news headlines."""
+    try:
+        # Analyze sentiment for each headline
+        sentiment_data = [analyze_sentiment(headline) for headline in parsed_news_df['headline']]
         
-        # Generate and display recommendation
-        recommendation = get_recommendation(parsed_and_scored_news)
-        st.write(recommendation)
+        # Convert to DataFrame
+        sentiment_df = pd.DataFrame(sentiment_data)
         
-        # Display a disclaimer
-        st.warning("Disclaimer: This recommendation is based solely on recent news sentiment and should not be considered as financial advice. Always do your own research and consult with a qualified financial advisor before making investment decisions.")
+        # Join with original news DataFrame
+        result_df = parsed_news_df.join(sentiment_df)
+        return result_df.set_index('datetime')
+    except Exception as e:
+        raise Exception(f"Error processing sentiments: {str(e)}")
+
+# Visualization functions
+def plot_sentiment_timeline(df, ticker):
+    """Create an hourly sentiment timeline plot."""
+    try:
+        hourly_sentiment = df['sentiment_score'].resample('H').mean()
         
-        # Create two columns for charts
-        col1, col2 = st.columns(2)
+        fig = px.bar(
+            hourly_sentiment,
+            title=f"{ticker} Hourly Sentiment Trend",
+            color=hourly_sentiment.values,
+            color_continuous_scale=['red', 'yellow', 'green'],
+            range_color=[-1, 1]
+        )
         
-        with col1:
-            fig_hourly = plot_hourly_sentiment(parsed_and_scored_news, ticker)
-            st.plotly_chart(fig_hourly, use_container_width=True)
-            
-        with col2:
-            fig_distribution = plot_sentiment_distribution(parsed_and_scored_news, ticker)
-            st.plotly_chart(fig_distribution, use_container_width=True)
+        fig.update_layout(
+            xaxis_title="Time",
+            yaxis_title="Sentiment Score",
+            coloraxis_colorbar_title="Sentiment",
+            showlegend=False,
+            height=400
+        )
+        
+        return fig
+    except Exception as e:
+        st.error(f"Error creating timeline plot: {str(e)}")
+        return None
 
-        description = f"""
-            ### Analysis Details
-            - The hourly sentiment chart shows the average sentiment score over time
-            - The pie chart shows the distribution of positive, negative, and neutral news
-            - The table below provides detailed analysis of each headline
-            - News headlines are sourced from FinViz
-            - Sentiment analysis uses the FinBERT-tone model, specifically trained for financial text tone analysis
-            """
-            
-        st.markdown(description)     
+def plot_sentiment_distribution(df, ticker):
+    """Create a pie chart of sentiment distribution."""
+    try:
+        tone_counts = df['tone'].value_counts()
         
-        # Prepare and display the news table
-        display_df = parsed_and_scored_news.copy()
-        display_df['link'] = display_df.apply(
-            lambda row: f'<a href="{row["link"]}" target="_blank">{"Valid✅" if row["is_valid"] else "Invalid❌"} Link</a>', 
-            axis=1
+        fig = px.pie(
+            values=tone_counts.values,
+            names=tone_counts.index,
+            title=f"{ticker} Sentiment Distribution",
+            color=tone_counts.index,
+            color_discrete_map={
+                'Positive': 'green',
+                'Neutral': 'yellow',
+                'Negative': 'red'
+            }
         )
         
-        # Reorder and rename columns for better presentation
-        display_df = display_df[['headline', 'tone', 'confidence', 'sentiment_score', 'link']]
-        display_df = display_df.rename(columns={
-            'headline': 'Headline',
-            'tone': 'Sentiment',
-            'confidence': 'Confidence',
-            'sentiment_score': 'Score',
-            'link': 'Source'
-        })
+        fig.update_layout(height=400)
+        return fig
+    except Exception as e:
+        st.error(f"Error creating distribution plot: {str(e)}")
+        return None
+
+def generate_recommendation(df):
+    """Generate trading recommendation based on sentiment analysis."""
+    try:
+        avg_sentiment = df['sentiment_score'].mean()
+        tone_counts = df['tone'].value_counts()
+        total_articles = len(df)
+        
+        positive_pct = tone_counts.get('Positive', 0) / total_articles * 100
+        negative_pct = tone_counts.get('Negative', 0) / total_articles * 100
         
-        st.write(display_df.to_html(escape=False), unsafe_allow_html=True)
+        if avg_sentiment >= 0.3 and positive_pct >= 50:
+            return "🟢 STRONG BUY", f"Strong positive sentiment (Score: {avg_sentiment:.2f}, {positive_pct:.1f}% positive news). The recent news suggests a very favorable outlook."
+        elif avg_sentiment >= 0.1:
+            return "🟡 MODERATE BUY", f"Moderately positive sentiment (Score: {avg_sentiment:.2f}, {positive_pct:.1f}% positive news). The recent news leans positive."
+        elif avg_sentiment <= -0.3 and negative_pct >= 50:
+            return "🔴 STRONG SELL", f"Strong negative sentiment (Score: {avg_sentiment:.2f}, {negative_pct:.1f}% negative news). The recent news suggests significant caution."
+        elif avg_sentiment <= -0.1:
+            return "🟡 MODERATE SELL", f"Moderately negative sentiment (Score: {avg_sentiment:.2f}, {negative_pct:.1f}% negative news). The recent news leans negative."
+        else:
+            return "⚪ NEUTRAL", f"Neutral sentiment (Score: {avg_sentiment:.2f}). The recent news shows mixed or neutral signals."
+    except Exception as e:
+        st.error(f"Error generating recommendation: {str(e)}")
+        return "⚠️ ERROR", "Unable to generate recommendation due to an error."
+
+# Main application
+def main():
+    st.title("📈 Stock News Sentiment Analyzer")
+    st.markdown("""
+        This application analyzes the sentiment of recent news articles for any given stock ticker using the FinBERT-tone model,
+        which is specifically trained for financial text analysis.
+    """)
     
-except Exception as e:
-    st.error(f"Error: {str(e)}")
-    st.write("Enter a correct stock ticker, e.g. 'AAPL' above and hit Enter.")    
+    # User input
+    ticker = st.text_input('Enter Stock Ticker (e.g., AAPL, GOOGL)', '').upper()
+    
+    if ticker:
+        try:
+            with st.spinner('Fetching and analyzing news...'):
+                # Get and process news
+                news_table = get_news(ticker)
+                parsed_news_df = parse_news(news_table)
+                analyzed_news = process_news_sentiment(parsed_news_df)
+                
+                # Generate recommendation
+                signal, explanation = generate_recommendation(analyzed_news)
+                
+                # Display recommendation
+                st.header(f"Analysis Results for {ticker}")
+                st.subheader(f"Signal: {signal}")
+                st.write(explanation)
+                
+                # Display charts
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    timeline_fig = plot_sentiment_timeline(analyzed_news, ticker)
+                    if timeline_fig:
+                        st.plotly_chart(timeline_fig, use_container_width=True)
+                
+                with col2:
+                    distribution_fig = plot_sentiment_distribution(analyzed_news, ticker)
+                    if distribution_fig:
+                        st.plotly_chart(distribution_fig, use_container_width=True)
+                
+                # Display news table
+                st.subheader("Recent News Analysis")
+                
+                # Prepare display DataFrame
+                display_df = analyzed_news.copy()
+                display_df['link'] = display_df.apply(
+                    lambda row: f'<a href="{row["link"]}" target="_blank">{"🔗" if row["is_valid"] else "❌"}</a>',
+                    axis=1
+                )
+                
+                # Format and display table
+                display_df = display_df[['headline', 'tone', 'confidence', 'sentiment_score', 'link']]
+                display_df = display_df.rename(columns={
+                    'headline': 'Headline',
+                    'tone': 'Sentiment',
+                    'confidence': 'Confidence',
+                    'sentiment_score': 'Score',
+                    'link': 'Link'
+                })
+                
+                st.write(display_df.to_html(escape=False), unsafe_allow_html=True)
+                
+                # Disclaimer
+                st.markdown("""
+                    ---
+                    **Disclaimer:** This analysis is based on news sentiment only and should not be considered as financial advice.
+                    Always conduct thorough research and consult with financial professionals before making investment decisions.
+                """)
+        
+        except Exception as e:
+            st.error(f"Error processing {ticker}: {str(e)}")
+            st.write("Please check the ticker symbol and try again.")
 
-hide_streamlit_style = """
-<style>
-#MainMenu {visibility: hidden;}
-footer {visibility: hidden;}
-</style>
-"""
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+# Run the application
+if __name__ == "__main__":
+    main()