Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,9 +1,11 @@
 import streamlit as st
 import requests
 import time
+import re
+import pandas as pd
 
-# Hugging Face API key from secrets
-API_KEY = st.secrets["API_KEY"]
+# ==== CONFIG ====
+API_KEY = st.secrets["API_KEY"]  # Reads from Hugging Face / .streamlit/secrets.toml
 HEADERS = {"Authorization": f"Bearer {API_KEY}"}
 
 API_URLS = {
@@ -11,48 +13,142 @@ API_URLS = {
     "Sentiment": "https://api-inference.huggingface.co/models/finiteautomata/bertweet-base-sentiment-analysis"
 }
 
+# ==== HELPERS ====
 def query(api_url, payload):
+    """Call Hugging Face inference API and return JSON or {'error':...}"""
     try:
-        res = requests.post(api_url, headers=HEADERS, json=payload, timeout=60)
-        if res.status_code != 200:
-            return {"error": f"HTTP {res.status_code}: {res.text}"}
-        return res.json()
-    except Exception as e:
-        return {"error": str(e)}
+        resp = requests.post(api_url, headers=HEADERS, json=payload, timeout=60)
+        if resp.status_code != 200:
+            return {"error": f"HTTP {resp.status_code}: {resp.text}"}
+        return resp.json()
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Request failed: {e}"}
 
+def split_sentences(text: str):
+    """
+    Split text into sentences/phrases by ., ?, !, ;, :, comma and newlines.
+    Keeps things simple and avoids external tokenizers.
+    """
+    # Split on end punctuation + whitespace, OR on newline, OR on comma followed by space
+    parts = re.split(r'(?<=[.!?;:])\s+|\n+|(?<=,)\s+', text.strip())
+    # Filter empties and strip
+    return [p.strip() for p in parts if p and p.strip()]
+
+def extract_scores_from_api_response(res):
+    """
+    Accepts HF response shapes like:
+      - [{'label': 'NEG', 'score': 0.86}, ...]  OR
+      - [[{'label': 'NEG','score':...}, ...]]  (nested list)
+    Returns a dict with numeric neg, neu, pos (floats 0..1) or None on unexpected.
+    """
+    sentiments = None
+    if isinstance(res, list):
+        # nested list (common with some HF endpoints)
+        if len(res) > 0 and isinstance(res[0], list):
+            sentiments = res[0]
+        # flat list
+        elif len(res) > 0 and isinstance(res[0], dict):
+            sentiments = res
+    if sentiments is None:
+        return None
+
+    neg = neu = pos = 0.0
+    for item in sentiments:
+        lab = item.get("label", "").upper()
+        sc = float(item.get("score", 0) or 0)
+        if "NEG" in lab:
+            neg = sc
+        elif "NEU" in lab:
+            neu = sc
+        elif "POS" in lab:
+            pos = sc
+    return {"neg": neg, "neu": neu, "pos": pos}
+
+# ==== STREAMLIT UI ====
 st.set_page_config(page_title="NLP Toolkit", page_icon="🧠", layout="centered")
-st.title("🧠 AI NLP Toolkit")
-st.write("Summarization & Sentiment Analysis using Hugging Face APIs 🚀")
+st.markdown("<h1 style='text-align: center; color: cyan;'>🧠 AI NLP Toolkit</h1>", unsafe_allow_html=True)
+st.write("Summarization & sentence-wise Sentiment Analysis.")
 
 tab1, tab2 = st.tabs(["📄 Summarizer", "📝 Sentiment Analysis"])
 
+# --- Summarizer (unchanged) ---
 with tab1:
-    text = st.text_area("Enter text to summarize:", height=200)
-    if st.button("Summarize"):
+    text = st.text_area("Enter text to summarize:", height=220)
+    if st.button("Summarize📝"):
         if not text.strip():
-            st.warning("⚠ Please enter some text.")
+            st.warning("Please enter text.")
         else:
             with st.spinner("Generating summary..."):
-                time.sleep(1)
-                res = query(API_URLS["Summarizer"], {"inputs": text})
-            if "error" in res:
-                st.error(res["error"])
+                time.sleep(0.8)
+                out = query(API_URLS["Summarizer"], {"inputs": text})
+            if "error" in out:
+                st.error(out["error"])
+            elif isinstance(out, list) and "summary_text" in out[0]:
+                st.success("Summary ready")
+                st.write(out[0]["summary_text"])
             else:
-                st.success("✅ Summary Generated")
-                st.write(res[0]['summary_text'])
+                st.error("Unexpected response from summarizer.")
 
+# --- Sentiment Analysis (sentence-wise, table + average) ---
 with tab2:
-    text = st.text_area("Enter text for sentiment analysis:", height=200, key="sent_text")
-    if st.button("Analyze Sentiment"):
-        if not text.strip():
-            st.warning("⚠ Please enter some text.")
+    text_sent = st.text_area("Enter text for sentiment analysis:", height=220, key="sent_text2")
+    if st.button("Analyze Sentiment🧠"):
+        if not text_sent.strip():
+            st.warning("Please enter text.")
         else:
-            with st.spinner("Analyzing sentiment..."):
-                time.sleep(1)
-                res = query(API_URLS["Sentiment"], {"inputs": text})
-            if "error" in res:
-                st.error(res["error"])
+            sentences = split_sentences(text_sent)
+            if len(sentences) == 0:
+                st.warning("No sentences found after splitting.")
             else:
-                st.success("✅ Sentiment Analysis Complete")
-                for item in res[0]:
-                    st.write(f"**{item['label']}** → {item['score']:.2f}")
+                rows = []
+                total_neg = total_neu = total_pos = 0.0
+                error_happened = False
+
+                with st.spinner("Analyzing sentences..."):
+                    time.sleep(0.5)
+                    for i, s in enumerate(sentences, start=1):
+                        res = query(API_URLS["Sentiment"], {"inputs": s})
+                        if isinstance(res, dict) and "error" in res:
+                            st.error(f"API error for sentence {i}: {res['error']}")
+                            error_happened = True
+                            break
+
+                        scores = extract_scores_from_api_response(res)
+                        if scores is None:
+                            st.error(f"Unexpected response format for sentence {i}.")
+                            error_happened = True
+                            break
+
+                        neg_pct = round(scores["neg"] * 100)
+                        neu_pct = round(scores["neu"] * 100)
+                        pos_pct = round(scores["pos"] * 100)
+
+                        rows.append({
+                            "#": i,
+                            "Sentence": f'"{s}"',
+                            "Negative": f"{neg_pct}%",
+                            "Neutral": f"{neu_pct}%",
+                            "Positive": f"{pos_pct}%"
+                        })
+
+                        total_neg += scores["neg"]
+                        total_neu += scores["neu"]
+                        total_pos += scores["pos"]
+
+                if not error_happened:
+                    n = len(sentences)
+                    avg_neg = round((total_neg / n) * 100)
+                    avg_neu = round((total_neu / n) * 100)
+                    avg_pos = round((total_pos / n) * 100)
+
+                    # Append average row
+                    rows.append({
+                        "#": "Avg",
+                        "Sentence": "—",
+                        "Negative": f"{avg_neg}%",
+                        "Neutral": f"{avg_neu}%",
+                        "Positive": f"{avg_pos}%"
+                    })
+
+                    df = pd.DataFrame(rows, columns=["#", "Sentence", "Negative", "Neutral", "Positive"])
+                    st.table(df)