Update app.py

app.py

@@ -3,12 +3,14 @@ import requests
 import torch
 import torch.nn as nn
 import re
-import os
+import datetime
 from transformers import AutoTokenizer
 
+# Load tokenizer and sentiment model
 MODEL = "cardiffnlp/xlm-twitter-politics-sentiment"
 tokenizer = AutoTokenizer.from_pretrained(MODEL)
 
+
 class ScorePredictor(nn.Module):
     def __init__(self, vocab_size, embedding_dim=128, hidden_dim=256, output_dim=1):
         super(ScorePredictor, self).__init__()
@@ -16,7 +18,7 @@ class ScorePredictor(nn.Module):
         self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
         self.fc = nn.Linear(hidden_dim, output_dim)
         self.sigmoid = nn.Sigmoid()
-        
+
     def forward(self, input_ids, attention_mask):
         embedded = self.embedding(input_ids)
         lstm_out, _ = self.lstm(embedded)
@@ -24,10 +26,12 @@ class ScorePredictor(nn.Module):
         output = self.fc(final_hidden_state)
         return self.sigmoid(output)
 
+# Load trained score predictor model
 score_model = ScorePredictor(tokenizer.vocab_size)
 score_model.load_state_dict(torch.load("score_predictor.pth"))
 score_model.eval()
 
+# preprocesses text
 def preprocess_text(text):
     text = text.lower()
     text = re.sub(r'http\S+', '', text)
@@ -35,6 +39,7 @@ def preprocess_text(text):
     text = re.sub(r'\s+', ' ', text).strip()
     return text
 
+# predicts sentiment
 def predict_sentiment(text):
     if not text:
         return 0.0
@@ -48,15 +53,11 @@ def predict_sentiment(text):
     input_ids, attention_mask = encoded_input["input_ids"], encoded_input["attention_mask"]
     with torch.no_grad():
         score = score_model(input_ids, attention_mask)[0].item()
-    min_val, max_val = 0.3, 0.9
-    scaled_score = (score - min_val) / (max_val - min_val)
-    # Clip to ensure it stays within [0, 1] in case original score was outside [0.3, 0.9]
-    scaled_score = max(0.0, min(1.0, scaled_score))
-    
-    return scaled_score
+    return score
 
+# uses Polygon API to fetch article
 def fetch_articles(ticker):
-    POLYGON_API_KEY = os.getenv('poly_api')
+    POLYGON_API_KEY = "cMCv7jipVvV4qLBikgzllNmW_isiODRR"
     url = f"https://api.polygon.io/v2/reference/news?ticker={ticker}&limit=1&apiKey={POLYGON_API_KEY}"
     try:
         response = requests.get(url)
@@ -71,54 +72,76 @@ def fetch_articles(ticker):
     except Exception as e:
         return [f"Error fetching articles for {ticker}: {str(e)}"]
 
+# allowed tickers
+ALLOWED_TICKERS = {"AAPL", "GOOG", "AMZN", "NVDA", "META"}
+
+# initialize cache
+sentiment_cache = {ticker: {"article": None, "sentiment": None, "timestamp": None} for ticker in ALLOWED_TICKERS}
+
+# checks if cache is valid 
+def is_cache_valid(cached_time, max_age_minutes=30):
+    if cached_time is None:
+        return False
+    now = datetime.datetime.utcnow()
+    age = now - cached_time
+    return age.total_seconds() < max_age_minutes * 60
+
+# analyzes the tikcers
 def analyze_ticker(ticker):
+    ticker = ticker.upper()
+    if ticker not in ALLOWED_TICKERS:
+        return [{
+            "article": f"Sorry, '{ticker}' is not supported. Please choose one of: {', '.join(sorted(ALLOWED_TICKERS))}.",
+            "sentiment": 0.0
+        }]
+
+    cache_entry = sentiment_cache[ticker]
+
+    # if cache is valid and article exists
+    if is_cache_valid(cache_entry["timestamp"]) and cache_entry["article"] is not None:
+
+        return [{
+            "article": cache_entry["article"],
+            "sentiment": cache_entry["sentiment"]
+        }]
+
+    # fetch new article and update cache if cache is invalid
     articles = fetch_articles(ticker)
-    sentiments = []
-    for article in articles:
-        clean_text = preprocess_text(article)
-        sentiment = predict_sentiment(clean_text)
-        
-        # Determine sentiment label
-        if sentiment > 0.6:
-            sentiment_label = "Negative"
-            emoji = "😊"
-        elif sentiment < 0.4:
-            sentiment_label = "Positive"
-            emoji = "😞"
-        else:
-            sentiment_label = "Neutral"
-            emoji = "😐"
-            
-        sentiments.append({
-            "article": article,
-            "sentiment": sentiment,
-            "sentiment_label": sentiment_label,
-            "emoji": emoji
-        })
-    return sentiments
-
-def gradio_interface(ticker):
+    if not articles:
+        return [{"article": "No articles found.", "sentiment": 0.0}]
+
+    article = articles[0]  
+
+    clean_text = preprocess_text(article)
+    sentiment = predict_sentiment(clean_text)
+
+    # update cache with current time
+    sentiment_cache[ticker] = {
+        "article": article,
+        "sentiment": sentiment,
+        "timestamp": datetime.datetime.utcnow()
+    }
+
+    return [{
+        "article": article,
+        "sentiment": sentiment
+    }]
+
+# display's sentiment
+def display_sentiment(ticker):
     results = analyze_ticker(ticker)
-    output = f"""
-    <h2>Sentiment Analysis for {ticker}</h2>
-    <div style='border: 1px solid #ccc; padding: 15px; border-radius: 5px; margin-bottom: 20px;'>
-        <h3>Article:</h3>
-        <p>{results[0]['article']}</p>
-        <h3>Sentiment:</h3>
-        <p>Score: {results[0]['sentiment']:.4f}</p>
-        <p>Label: {results[0]['sentiment_label']} {results[0]['emoji']}</p>
-    </div>
-    """
-    return output
-
-# Create Gradio interface
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=gr.Textbox(label="Enter Stock Ticker", placeholder="AAPL, MSFT, GOOGL..."),
-    outputs=gr.HTML(label="Sentiment Analysis Results"),
-    title="Stock News Sentiment Analyzer",
-    description="Enter a stock ticker to analyze the sentiment of recent news articles about that company.",
-    examples=[["AAPL"], ["MSFT"], ["TSLA"]]
-)
-
-iface.launch()
+    html_output = "<h2>Sentiment Analysis</h2><ul>"
+    for r in results:
+        html_output += f"<li><b>{r['article']}</b><br>Score: {r['sentiment']:.2f}</li>"
+    html_output += "</ul>"
+    return html_output
+
+# search feature
+with gr.Blocks() as demo:
+    gr.Markdown("# Ticker Sentiment Analysis")
+    ticker_input = gr.Textbox(label="Enter Ticker Symbol (e.g., AAPL)")
+    output_html = gr.HTML()
+    analyze_btn = gr.Button("Analyze")
+    analyze_btn.click(fn=display_sentiment, inputs=[ticker_input], outputs=[output_html])
+
+demo.launch()