Update app.py

adds these changes: more robust print statements, checks all tickers, SPY comparison, account for all exceptions, make cache shorter, adds new polygon api , timestamp of when article collected and scored

app.py

@@ -91,27 +91,31 @@ def predict_sentiment(text):
 def fetch_articles(ticker):
     POLYGON_API_KEY = "cMCv7jipVvV4qLBikgzllNmW_isiODRR"
     url = f"https://api.polygon.io/v2/reference/news?ticker={ticker}&limit=1&apiKey={POLYGON_API_KEY}"
+    print(f"[FETCH] {ticker}: {url}")
     try:
-        response = requests.get(url)
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
         data = response.json()
-        if "results" in data and len(data["results"]) > 0:
+        if data.get("results"):
             article = data["results"][0]
             title = article.get("title", "")
             description = article.get("description", "")
-            return [title+description]
-        else:
-            return [f"No news articles found for {ticker}."]
-    except Exception as e:
-        return [f"Error fetching articles for {ticker}: {str(e)}"]
-
-# allowed tickers
-ALLOWED_TICKERS = {"AAPL", "GOOG", "AMZN", "NVDA", "META",'TSLA','QQQ','SPY'}
+            return title + " " + description
+        return f"No news articles found for {ticker}."
+    # checks specific HTTP errors
+    except requests.exceptions.HTTPError as http_err:
+        print(f"[ERROR] HTTP error for {ticker}: {http_err}")
+        return f"HTTP error when fetching {ticker}: {http_err}"
+    # catches any other error
+    except Exception as exc:
+        print(f"[ERROR] Unexpected error for {ticker}: {exc}")
+        return f"Error fetching articles for {ticker}: {exc}"
 
 # initialize cache
-sentiment_cache = {ticker: {"article": None, "sentiment": None, "timestamp": None} for ticker in ALLOWED_TICKERS}
+sentiment_cache = {}
 
 # checks if cache is valid 
-def is_cache_valid(cached_time, max_age_minutes=30):
+def is_cache_valid(cached_time, max_age_minutes=10):
     if cached_time is None:
         return False
     now = datetime.datetime.utcnow()
@@ -119,73 +123,61 @@ def is_cache_valid(cached_time, max_age_minutes=30):
     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)
-    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
-    }]
-
-def display_sentiment(ticker):
-    results = analyze_ticker(ticker)
-
-    html_output = "<h2>Sentiment Analysis</h2><ul>"
-    if results:
-        for r in results:
-            html_output += f"<li><b>{r['article']}</b><br>Score: {r['sentiment']:.2f}</li>"
-    else:
-        html_output += "<li>No sentiment data available for this ticker.</li>"
-    html_output += "</ul>"
-    return html_output
+def analyze_ticker(user_ticker: str):
+    user_ticker = user_ticker.upper().strip()
+    tickers_to_check = list({user_ticker, "SPY"})  
+    results = []
+
+    for tk in tickers_to_check:
+        cached = sentiment_cache.get(tk, {})
+        if cached and is_cache_valid(cached.get("timestamp")):
+            print(f"[CACHE] Using cached sentiment for {tk}")
+            results.append({**cached, "ticker": tk})
+            continue
+
+        print(f"[INFO] Fetching fresh data for {tk}")
+        article_text = fetch_articles(tk)
+        sentiment_score = predict_sentiment(article_text)
+        timestamp = datetime.datetime.utcnow()
+
+        cache_entry = {
+            "article": article_text,
+            "sentiment": sentiment_score,
+            "timestamp": timestamp,
+        }
+        sentiment_cache[tk] = cache_entry
+        results.append({**cache_entry, "ticker": tk})
+
+    # sort so user ticker appears first, SPY second
+    results.sort(key=lambda x: 0 if x["ticker"] == user_ticker else 1)
+    return results
+
+
+def display_sentiment(results):
+    html = "<h2>Sentiment Analysis</h2><ul>"
+    for r in results:
+        ts_str = r["timestamp"].strftime("%Y‑%m‑%d %H:%M:%S UTC")
+        html += (
+            f"<li><b>{r['ticker']}</b> &nbsp;({ts_str})<br>"
+            f"{r['article']}<br>"
+            f"<i>Sentiment score:</i> {r['sentiment']:.2f}" ")</li>"
+        )
+    html += "</ul>"
+    return html
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Ticker Sentiment Analysis")
-    ticker_input = gr.Textbox(label="Enter Ticker Symbol (e.g., AAPL)")
+    gr.Markdown("# Ticker vs. SPY Sentiment Tracker")
+    input_box = gr.Textbox(label="Enter any ticker symbol (e.g., AAPL)")
     output_html = gr.HTML()
-    analyze_btn = gr.Button("Analyze")
-
-    analyze_btn.click(
-        fn=lambda t: "<h2>Fetching and scoring sentiment for... " + t + "</h2><p>Please wait...</p>",
-        inputs=[ticker_input],
-        outputs=[output_html],
-        queue=False
-    ).then(
-        fn=display_sentiment,
-        inputs=[ticker_input],
-        outputs=[output_html]
+    run_btn = gr.Button("Analyze")
+
+    def _placeholder(t):
+        return f"<h3>Gathering latest articles for {t.upper()} and SPY … please wait.</h3>"
+
+    run_btn.click(_placeholder, inputs=input_box, outputs=output_html, queue=False).then(
+        lambda t: display_sentiment(analyze_ticker(t)),
+        inputs=input_box,
+        outputs=output_html,
     )
 
 demo.launch()