Update app.py

app.py

@@ -1,203 +1,70 @@
 import streamlit as st
 import pandas as pd
-import torch
-from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
 import feedparser
-import requests
-import re
-from datetime import datetime
-import time
-from huggingface_hub import notebook_login
-
-notebook_login()
-
-# Page configuration
-st.set_page_config(
-    page_title="Stock Market Sentiment Analyzer",
-    page_icon="📈",
-    layout="wide"
-)
-
-# Create two columns for the header
-col1, col2 = st.columns([0.2, 1])
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
 
-with col1:
-    # You can replace this with your own logo
-    st.image("https://api.dicebear.com/7.x/shapes/svg?seed=stocks", width=80)
+# Load the trained model and tokenizer
+MODEL_NAME = "financial-sentiment-model"
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 
-with col2:
-    st.title("Stock Market Sentiment Analyzer")
+LABEL_MAP = {0: "bullish", 1: "bearish", 2: "neutral"}
 
-st.markdown("**Analyze real-time market sentiment from news articles using DistilBERT-based deep learning model.**")
+# RSS Feed URLs
+rss_feeds = {
+    "Benzinga": ["https://www.benzinga.com/feeds/news", "https://www.benzinga.com/feeds/analysis"],
+    "Yahoo News": ["https://finance.yahoo.com/rss/topstories"]
+}
 
-# Sidebar content
-st.sidebar.subheader("About the App")
-st.sidebar.info(
-    """This app uses 🤗 HuggingFace's DistilBERT model fine-tuned on financial news data 
-    to predict market sentiment in real-time. It processes news from various financial RSS feeds 
-    and classifies sentiment as bullish, bearish, or neutral."""
-)
+def fetch_rss_feed(url):
+    """Fetch articles from an RSS feed."""
+    feed = feedparser.parse(url)
+    articles = []
+    for entry in feed.entries:
+        articles.append({"title": entry.title, "link": entry.link})
+    return articles
+
+def analyze_sentiment(text):
+    """Analyze sentiment of a given text."""
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding="max_length", max_length=128)
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predictions = torch.argmax(outputs.logits, dim=-1).item()
+    return LABEL_MAP[predictions]
 
-st.sidebar.markdown("### Configuration")
-st.sidebar.markdown("**Available RSS Feeds:**")
-feed_options = {
-    "Benzinga Large Cap": "https://www.benzinga.com/news/large-cap/feed",
-    "Market Watch": "http://feeds.marketwatch.com/marketwatch/marketpulse/",
-    "Yahoo Finance": "https://finance.yahoo.com/news/rssindex"
-}
-selected_feed = st.sidebar.selectbox("Choose News Source:", list(feed_options.keys()))
+def main():
+    st.title("Financial News Sentiment Analysis")
 
-refresh_interval = st.sidebar.slider(
-    "Refresh Interval (seconds)",
-    min_value=30,
-    max_value=300,
-    value=60,
-    help="How often to fetch new articles"
-)
+    # Sidebar: Feed Selection
+    st.sidebar.header("Select RSS Feeds")
+    selected_feeds = st.sidebar.multiselect("Choose feeds:", options=rss_feeds.keys(), default=list(rss_feeds.keys()))
 
-# Cache the model loading
-@st.cache_resource
-def load_model():
-    """Load the sentiment analysis model and tokenizer"""
-    try:
-        model = DistilBertForSequenceClassification.from_pretrained('./sentiment_model')
-        tokenizer = DistilBertTokenizer.from_pretrained('./sentiment_model')
-        return model, tokenizer
-    except Exception as e:
-        st.error(f"Error loading model: {str(e)}")
-        return None, None
+    if not selected_feeds:
+        st.warning("Please select at least one RSS feed.")
+        return
 
-def predict_sentiment(text, model, tokenizer):
-    """Predict sentiment for given text"""
-    try:
-        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
-        outputs = model(**inputs)
-        logits = outputs.logits
-        probabilities = torch.nn.functional.softmax(logits, dim=1)
-        predicted_class = torch.argmax(logits, dim=1).item()
-        confidence = probabilities[0][predicted_class].item()
-        
-        sentiment_map = {0: 'bearish', 1: 'bullish', 2: 'neutral'}
-        return sentiment_map[predicted_class], confidence
-    except Exception as e:
-        st.error(f"Error in sentiment prediction: {str(e)}")
-        return "error", 0.0
+    st.sidebar.header("About")
+    st.sidebar.info(
+        "This app fetches financial news from RSS feeds and analyzes sentiment (buy, sell, hold) based on the latest news titles."
+    )
 
-def fetch_articles(feed_url):
-    """Fetch and parse RSS feed"""
-    try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        }
-        response = requests.get(feed_url, headers=headers, timeout=10)
-        feed = feedparser.parse(response.content)
-        
-        articles = []
-        for entry in feed.entries[:10]:  # Limit to 10 most recent articles
-            article = {
-                'title': entry.title,
-                'link': entry.link,
-                'summary': entry.get('summary', entry.title),
-                'published': entry.get('published', 'No date'),
-                'tickers': re.findall(r'\((\w+)\)', entry.title)
-            }
-            articles.append(article)
-        return articles
-    except Exception as e:
-        st.error(f"Error fetching articles: {str(e)}")
-        return []
+    # Fetch and Display Articles
+    st.header("Latest Financial News")
+    articles = []
+    for feed_name in selected_feeds:
+        for url in rss_feeds[feed_name]:
+            articles.extend(fetch_rss_feed(url))
 
-def main():
-    # Load model
-    model, tokenizer = load_model()
-    if model is None or tokenizer is None:
-        st.error("Could not load the model. Please check if model files exist.")
+    if not articles:
+        st.write("No articles found.")
         return
 
-    # Main content area
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        st.subheader("Latest Market News Analysis")
-        articles_container = st.empty()
-        
-        while True:
-            try:
-                with st.spinner('Fetching latest articles...'):
-                    articles = fetch_articles(feed_options[selected_feed])
-                
-                if articles:
-                    with articles_container.container():
-                        for article in articles:
-                            sentiment, confidence = predict_sentiment(
-                                article['summary'],
-                                model,
-                                tokenizer
-                            )
-                            
-                            # Create card-like display for each article
-                            with st.expander(f"📰 {article['title']}", expanded=False):
-                                st.write(f"**Published:** {article['published']}")
-                                
-                                # Display tickers if found
-                                if article['tickers']:
-                                    st.write(f"**Tickers:** {', '.join(article['tickers'])}")
-                                
-                                # Color-coded sentiment with confidence
-                                sentiment_colors = {
-                                    'bullish': 'green',
-                                    'bearish': 'red',
-                                    'neutral': 'grey'
-                                }
-                                st.markdown(
-                                    f"**Sentiment:** :{sentiment_colors[sentiment]}[{sentiment.upper()}] "
-                                    f"({confidence:.1%} confidence)"
-                                )
-                                
-                                st.write("**Summary:**")
-                                st.write(article['summary'])
-                                st.write(f"[Read full article]({article['link']})")
-                
-                        st.caption(f"Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-                
-                # Statistics in the second column
-                with col2:
-                    st.subheader("Sentiment Overview")
-                    
-                    # Calculate sentiment distribution
-                    sentiments = [predict_sentiment(a['summary'], model, tokenizer)[0] 
-                                for a in articles]
-                    
-                    # Create metrics
-                    sentiment_counts = pd.Series(sentiments).value_counts()
-                    total = len(sentiments)
-                    
-                    # Display metrics with gauges
-                    col_a, col_b, col_c = st.columns(3)
-                    with col_a:
-                        bullish_count = sentiment_counts.get('bullish', 0)
-                        st.metric("Bullish", f"{bullish_count}/{total}")
-                    with col_b:
-                        bearish_count = sentiment_counts.get('bearish', 0)
-                        st.metric("Bearish", f"{bearish_count}/{total}")
-                    with col_c:
-                        neutral_count = sentiment_counts.get('neutral', 0)
-                        st.metric("Neutral", f"{neutral_count}/{total}")
-                    
-                    # Display sentiment distribution chart
-                    st.bar_chart(sentiment_counts)
-                
-                time.sleep(refresh_interval)
-                
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
-                time.sleep(refresh_interval)
-
-# Footer
-st.sidebar.divider()
-st.sidebar.caption("Made with Streamlit and HuggingFace 🤗")
+    for article in articles:
+        sentiment = analyze_sentiment(article["title"])
+        st.subheader(article["title"])
+        st.write(f"Sentiment: **{sentiment}**")
+        st.write(f"[Read more]({article['link']})")
 
 if __name__ == "__main__":
-    main()
-
-#test
+    main()