Update app.py

app.py

@@ -1,27 +1,135 @@
+# app.py
+# ------------------------------------------------------------
+# Social Media Sentiment Analyzer (Gemini + HF)
+# - Posts can be generated by Gemini (toggle)
+# - Sentiment via Gemini or HF Transformers (toggle)
+# - Pretty Plotly charts + animated background
+#
+# Requires (in requirements.txt):
+# gradio>=4.36.1
+# plotly>=5.22.0
+# transformers>=4.41.2
+# torch --extra-index-url https://download.pytorch.org/whl/cpu
+# google-generativeai>=0.7.2
+# pandas
+# ------------------------------------------------------------
+
 import os
+import json
 import random
+import re
+from typing import List, Tuple, Dict
+
 import gradio as gr
-import plotly.express as px
 import pandas as pd
-from transformers import pipeline
-import google.generativeai as genai
-
-# -----------------------------
-# Load Hugging Face Sentiment Model
-# -----------------------------
-sentiment_model = pipeline("sentiment-analysis")
-
-# -----------------------------
-# Configure Gemini (Key from Secrets)
-# -----------------------------
-GEMINI_KEY = os.getenv("GEMINI_API_KEY")  # add in Hugging Face Secrets
-if GEMINI_KEY:
+import plotly.express as px
+
+# --- Optional Gemini import (handled gracefully) ---
+GEMINI_AVAILABLE = True
+try:
+    import google.generativeai as genai  # type: ignore
+except Exception:
+    GEMINI_AVAILABLE = False
+
+# --- Optional HF Transformers sentiment pipeline (CPU friendly) ---
+HF_AVAILABLE = True
+try:
+    from transformers import pipeline
+except Exception:
+    HF_AVAILABLE = False
+
+
+# ------------------ Config ------------------
+
+MAX_POSTS = 50
+DEFAULT_MODEL_HF = "distilbert-base-uncased-finetuned-sst-2-english"
+GEMINI_MODEL_FAST = "gemini-1.5-flash"
+
+GEMINI_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+if GEMINI_AVAILABLE and GEMINI_KEY:
     genai.configure(api_key=GEMINI_KEY)
 
-# -----------------------------
-# Fake Post Generator (simulate Twitter)
-# -----------------------------
-def generate_fake_posts(hashtag, n=20):
+
+# ------------------ Utilities ------------------
+
+def clean_posts_list(text: str, n: int) -> List[str]:
+    """
+    Try to parse a JSON array of strings; if not, split lines or bullets.
+    Ensures length <= n and removes duplicates while keeping order.
+    """
+    text = text.strip()
+    posts: List[str] = []
+
+    # Try JSON array
+    if text.startswith("["):
+        try:
+            arr = json.loads(text)
+            if isinstance(arr, list):
+                posts = [str(x).strip() for x in arr]
+        except Exception:
+            posts = []
+
+    # If empty, try to parse as numbered/bulleted lines
+    if not posts:
+        lines = [ln.strip() for ln in re.split(r"[\r\n]+", text) if ln.strip()]
+        cleaned = []
+        for ln in lines:
+            ln = re.sub(r"^[\-\*\d\.\)\s]+", "", ln)  # strip bullets/nums
+            if ln:
+                cleaned.append(ln)
+        posts = cleaned
+
+    # Deduplicate while preserving order
+    seen = set()
+    unique = []
+    for p in posts:
+        if p not in seen:
+            seen.add(p)
+            unique.append(p)
+
+    # Trim length and empty values
+    unique = [p for p in unique if p.strip()][:n]
+    return unique
+
+
+def generate_posts_gemini(hashtag: str, n: int) -> Tuple[List[str], str]:
+    """
+    Ask Gemini to create n short, realistic social posts.
+    Returns (posts, info_message). If fails, returns ([], reason).
+    """
+    if not (GEMINI_AVAILABLE and GEMINI_KEY):
+        return [], "Gemini unavailable (missing package or key)."
+
+    prompt = f"""
+You are a social media copy expert.
+
+Generate {n} diverse, realistic, short social posts about the topic {hashtag}.
+Constraints:
+- sound like real posts/tweets (casual, short, natural)
+- include some emojis and variety in sentiment (positive, negative, neutral)
+- avoid hate speech, slurs, or unsafe content
+- return ONLY a JSON array of strings, no extra text
+
+Example:
+["Love {hashtag}! 🚀", "Not sure about {hashtag}… 🤔", "This {hashtag} launch was underwhelming 😕"]
+"""
+
+    try:
+        model = genai.GenerativeModel(GEMINI_MODEL_FAST)
+        resp = model.generate_content(prompt)
+        text = resp.text or ""
+        posts = clean_posts_list(text, n)
+        if posts:
+            return posts, f"Generated {len(posts)} posts via Gemini."
+        return [], "Gemini responded but parsing returned no posts."
+    except Exception as e:
+        return [], f"Gemini error: {e}"
+
+
+def generate_posts_fallback(hashtag: str, n: int) -> List[str]:
+    """
+    Local lightweight fallback templates.
+    """
     templates = [
         f"I love {hashtag}! It's amazing ❤️",
         f"I'm disappointed with {hashtag} 💔",
@@ -30,119 +138,293 @@ def generate_fake_posts(hashtag, n=20):
         f"People are talking about {hashtag} everywhere 🌍",
         f"{hashtag} campaign is the best thing this year 🎉",
         f"Super excited about {hashtag} 🔥",
-        f"{hashtag} is the worst thing ever 😡"
+        f"{hashtag} is the worst thing ever 😡",
+        f"Mixed feelings about {hashtag} today 😶‍🌫️",
+        f"Curious where {hashtag} goes next 👀",
     ]
-    return random.choices(templates, k=n)
-
-# -----------------------------
-# Run HuggingFace Analysis
-# -----------------------------
-def analyze_with_hf(posts):
-    results = sentiment_model(posts)
-    sentiments = []
-    for post, res in zip(posts, results):
-        sentiments.append({
-            "Post": post,
-            "Sentiment": res["label"],
-            "Confidence": round(res["score"], 2)
-        })
-    return sentiments
-
-# -----------------------------
-# Run Gemini Advanced Analysis
-# -----------------------------
-def analyze_with_gemini(posts):
-    if not GEMINI_KEY:
-        return analyze_with_hf(posts)  # fallback
-    
-    sentiments = []
-    for post in posts:
-        try:
-            prompt = f"""Classify the sentiment of this social media post as Positive, Negative, or Neutral. 
-            Return only JSON with 'label' and 'confidence' between 0 and 1.
-
-            Post: "{post}"
-            """
-            response = genai.GenerativeModel("gemini-1.5-flash").generate_content(prompt)
-            
-            # crude parse
-            text = response.text.strip()
-            if "Positive" in text:
-                label = "POSITIVE"
-            elif "Negative" in text:
-                label = "NEGATIVE"
-            else:
-                label = "NEUTRAL"
-
-            sentiments.append({
-                "Post": post,
-                "Sentiment": label,
-                "Confidence": 0.95
-            })
-        except:
-            sentiments.append({
-                "Post": post,
-                "Sentiment": "NEUTRAL",
-                "Confidence": 0.5
-            })
-    return sentiments
-
-# -----------------------------
-# Main Function
-# -----------------------------
-def run_analysis(hashtag, n_posts, vis_type, use_gemini):
-    posts = generate_fake_posts(hashtag, n_posts)
-    
-    if use_gemini:
-        data = analyze_with_gemini(posts)
-        source_info = f"Analyzed with Gemini AI: {len(posts)} posts"
+    # sample with replacement for diversity
+    return random.sample(templates, k=min(len(templates), n)) if n <= len(templates) else random.choices(templates, k=n)
+
+
+def analyze_sentiment_hf(posts: List[str]) -> List[Dict]:
+    """
+    HF pipeline sentiment: POSITIVE/NEGATIVE with score
+    (Neutral simulated lightly based on score band).
+    """
+    if not HF_AVAILABLE:
+        # If transformers not available, return neutral placeholders
+        return [{"sentiment": "NEUTRAL", "confidence": 0.5} for _ in posts]
+
+    nlp = pipeline("sentiment-analysis", model=DEFAULT_MODEL_HF)
+    results = nlp(posts)
+    out = []
+    for r in results:
+        label = r["label"].upper()
+        score = float(r["score"])
+        # Project a basic neutral band to make visuals richer
+        if 0.45 < score < 0.55:
+            sent = "NEUTRAL"
+            conf = 0.5
+        else:
+            sent = "POSITIVE" if label.startswith("POS") else "NEGATIVE"
+            conf = score
+        out.append({"sentiment": sent, "confidence": round(conf, 2)})
+    return out
+
+
+def analyze_sentiment_gemini(posts: List[str]) -> List[Dict]:
+    """
+    Gemini multi-class sentiment with confidence 0..1.
+    """
+    if not (GEMINI_AVAILABLE and GEMINI_KEY):
+        return [{"sentiment": "NEUTRAL", "confidence": 0.5} for _ in posts]
+
+    prompt = f"""
+Classify sentiment of each post as one of: POSITIVE, NEGATIVE, NEUTRAL.
+Return JSON array of objects with fields: sentiment, confidence (0..1).
+No extra text.
+
+Posts:
+{json.dumps(posts, ensure_ascii=False, indent=2)}
+Expected JSON schema:
+[{{"sentiment":"POSITIVE|NEGATIVE|NEUTRAL","confidence":0.87}}, ...]
+"""
+    try:
+        model = genai.GenerativeModel(GEMINI_MODEL_FAST)
+        resp = model.generate_content(prompt)
+        text = resp.text or ""
+        # Find JSON array robustly
+        match = re.search(r"\[[\s\S]+\]", text)
+        if match:
+            arr = json.loads(match.group(0))
+            clean = []
+            for i, it in enumerate(arr[:len(posts)]):
+                s = str(it.get("sentiment", "NEUTRAL")).upper()
+                if s not in {"POSITIVE", "NEGATIVE", "NEUTRAL"}:
+                    s = "NEUTRAL"
+                c = float(it.get("confidence", 0.5))
+                c = max(0.0, min(1.0, c))
+                clean.append({"sentiment": s, "confidence": round(c, 2)})
+            # If Gemini returned fewer rows, pad neutrals
+            while len(clean) < len(posts):
+                clean.append({"sentiment": "NEUTRAL", "confidence": 0.5})
+            return clean
+    except Exception:
+        pass
+    # fallback neutrals
+    return [{"sentiment": "NEUTRAL", "confidence": 0.5} for _ in posts]
+
+
+def build_plot(df: pd.DataFrame, vis: str, hashtag: str):
+    """
+    Build nice Plotly figure.
+    """
+    vis = (vis or "Bar").lower()
+    # Count per sentiment
+    counts = df["Sentiment"].value_counts().reindex(["POSITIVE", "NEUTRAL", "NEGATIVE"], fill_value=0)
+    count_df = counts.reset_index()
+    count_df.columns = ["Sentiment", "Count"]
+
+    if vis == "pie":
+        fig = px.pie(
+            count_df, values="Count", names="Sentiment",
+            title=f"Sentiment Distribution for {hashtag}",
+            hole=0.45
+        )
+        fig.update_traces(textposition="inside", pull=[0.03, 0.03, 0.03])
+    elif vis == "line":
+        # rolling positive ratio
+        map_vals = df["Sentiment"].map({"POSITIVE": 1, "NEUTRAL": 0.5, "NEGATIVE": 0})
+        roll = map_vals.rolling(window=max(3, min(10, len(df)//3)), min_periods=1).mean()
+        fig = px.line(
+            x=list(range(1, len(df)+1)), y=roll,
+            labels={"x": "Post Index", "y": "Rolling Sentiment (0..1)"},
+            title=f"Sentiment Rolling Trend for {hashtag}"
+        )
     else:
-        data = analyze_with_hf(posts)
-        source_info = f"Analyzed with Hugging Face Transformers: {len(posts)} posts"
-    
-    df = pd.DataFrame(data)
-
-    # Chart
-    if vis_type == "Bar":
-        fig = px.bar(df, x="Sentiment", title=f"Sentiment Distribution for {hashtag}")
-    elif vis_type == "Line":
-        fig = px.line(df, y="Confidence", title=f"Sentiment Rolling Trend for {hashtag}")
-    elif vis_type == "Pie":
-        fig = px.pie(df, names="Sentiment", title=f"Sentiment Share for {hashtag}")
+        fig = px.bar(
+            count_df, x="Sentiment", y="Count",
+            title=f"Sentiment Distribution for {hashtag}"
+        )
+
+    fig.update_layout(
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(size=14),
+        title_x=0.02,
+        hovermode="x unified",
+        margin=dict(l=40, r=20, t=60, b=40),
+    )
+    return fig
+
+
+# ------------------ Main callback ------------------
+
+def run_analysis(
+    hashtag: str,
+    n_posts: int,
+    vis_type: str,
+    use_gemini_posts: bool,
+    use_gemini_analysis: bool
+):
+    hashtag = hashtag.strip()
+    if not hashtag:
+        return (
+            gr.update(value=pd.DataFrame([])),
+            gr.update(value=None),
+            "⚠️ Please enter a hashtag.",
+            "—", 0, 0
+        )
+
+    n_posts = max(5, min(MAX_POSTS, int(n_posts or 20)))
+
+    # 1) Generate posts
+    posts = []
+    info_posts = ""
+    gemini_count = 0
+
+    if use_gemini_posts:
+        posts, info_posts = generate_posts_gemini(hashtag, n_posts)
+        gemini_count = len(posts)
+
+    if len(posts) < n_posts:
+        # Top up with fallback to avoid looking repetitive if Gemini returned few
+        remaining = n_posts - len(posts)
+        posts += generate_posts_fallback(hashtag, remaining)
+        info_posts += f" | Fallback added: {remaining}"
+
+    # 2) Sentiment
+    if use_gemini_analysis:
+        analysis = analyze_sentiment_gemini(posts)
+        analysis_engine = "Gemini"
     else:
-        fig = px.scatter(df, x="Sentiment", y="Confidence", title=f"Scatter of Sentiments for {hashtag}")
+        analysis = analyze_sentiment_hf(posts)
+        analysis_engine = "HF Transformers"
+
+    # 3) DataFrame
+    df = pd.DataFrame({
+        "Post": posts,
+        "Sentiment": [a["sentiment"] for a in analysis],
+        "Confidence": [a["confidence"] for a in analysis],
+    })
 
-    return df, fig, source_info
+    # 4) Plot
+    fig = build_plot(df, vis_type, hashtag)
 
+    # 5) Status
+    status = f"Generated {len(posts)} posts · {gemini_count} via Gemini · Analyzed with {analysis_engine}"
+    return df, fig, status, analysis_engine, gemini_count, len(posts) - gemini_count
 
-# -----------------------------
-# Gradio UI
-# -----------------------------
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange", secondary_hue="blue")) as demo:
-    gr.Markdown("<h1 style='text-align:center;'>🚀 Social Media Sentiment Analyzer</h1>")
-    gr.Markdown("<p style='text-align:center;'>Stream posts · Analyze moods · Visualize trends</p>")
+
+# ------------------ UI ------------------
+
+THEME = gr.themes.Soft(
+    primary_hue="indigo",
+    neutral_hue="slate",
+).set(
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+)
+
+CUSTOM_CSS = """
+/* Starry gradient background */
+body { background: radial-gradient(1200px 600px at 60% -10%, rgba(0,255,255,0.15), transparent 60%),
+                    radial-gradient(900px 400px at 20% -10%, rgba(255,0,255,0.12), transparent 60%),
+                    linear-gradient(160deg, #0b1020, #100a25 35%, #0a0f2d 70%); }
+#root { background: transparent !important; }
+
+.starfield, .planet {
+  position: fixed; inset: 0; pointer-events:none; z-index: -1;
+}
+.starfield::before, .starfield::after {
+  content: ""; position: absolute; inset: 0;
+  background-image:
+    radial-gradient(2px 2px at 20% 30%, rgba(255,255,255,.6) 50%, transparent 51%),
+    radial-gradient(1.5px 1.5px at 70% 60%, rgba(255,255,255,.4) 50%, transparent 51%),
+    radial-gradient(1.7px 1.7px at 40% 80%, rgba(255,255,255,.5) 50%, transparent 51%),
+    radial-gradient(1.4px 1.4px at 90% 20%, rgba(255,255,255,.35) 50%, transparent 51%);
+  animation: twinkle 6s infinite ease-in-out alternate;
+}
+@keyframes twinkle { from {opacity:.4} to {opacity:1} }
+.planet::before{
+  content:""; position:absolute; width:220px; height:220px; right:8%; top:12%;
+  background: radial-gradient(circle at 30% 30%, #4ef4d7, #2b7dff 40%, #2339a1 70%, #0d1130 80%);
+  border-radius:50%; filter: blur(0.3px) drop-shadow(0 0 18px rgba(70,180,255,.25));
+  animation: floaty 10s ease-in-out infinite;
+}
+@keyframes floaty { 50% { transform: translateY(12px) translateX(-8px) } }
+
+.gradio-container { max-width: 1100px !important; margin: 0 auto; }
+.header-title { font-size: 2.1rem; font-weight: 800; letter-spacing: .5px; color: #d9f0ff; }
+.header-sub { color: #bcd7ff; opacity: .85; }
+
+.card {
+  border: 1px solid rgba(255,255,255,.08);
+  background: rgba(255,255,255,.05);
+  backdrop-filter: blur(10px);
+  border-radius: 18px;
+  transition: transform .2s ease, box-shadow .2s ease;
+}
+.card:hover { transform: translateY(-2px); box-shadow: 0 18px 40px rgba(0,0,0,.25); }
+
+label, .label { color:#eaf2ff !important; font-weight:600; }
+
+.status-badge{
+  padding:.4rem .7rem; border-radius:999px; background:rgba(0,0,0,.35); color:#e6f7ff;
+  display:inline-flex; gap:.5rem; align-items:center; border:1px solid rgba(255,255,255,.12)
+}
+"""
+
+with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Social Media Sentiment Analyzer") as demo:
+    gr.HTML('<div class="starfield"></div><div class="planet"></div>')
+    gr.Markdown(
+        """
+<div class="header-title">🚀 Social Media Sentiment Analyzer</div>
+<div class="header-sub">Stream-like posts • Analyze moods • Visualize trends — with Gemini & HF</div>
+        """
+    )
 
     with gr.Row():
-        with gr.Column(scale=1):
-            hashtag = gr.Textbox(label="Enter Hashtag", value="#gla")
-            n_posts = gr.Slider(5, 50, value=20, step=1, label="Number of Posts")
-            vis_type = gr.Dropdown(["Bar", "Line", "Pie", "Scatter"], label="Choose Visualization", value="Bar")
-            use_gemini = gr.Checkbox(label="Use Gemini Advanced Analysis", value=False)
-            run_btn = gr.Button("🔍 Run Analysis", variant="primary")
-        
-        with gr.Column(scale=2):
-            output_table = gr.Dataframe(headers=["Post", "Sentiment", "Confidence"], wrap=True)
-            output_plot = gr.Plot()
-            source_label = gr.Label(label="Analysis Source")
+        with gr.Column(scale=5, elem_classes=["card"]):
+            hashtag = gr.Textbox(label="Enter Hashtag", placeholder="#YourTopic", value="#gla university")
+            n_posts = gr.Slider(5, MAX_POSTS, value=20, step=1, label="Number of Posts (max 50)")
+            vis_type = gr.Dropdown(["Bar", "Pie", "Line"], value="Bar", label="Choose Visualization")
+            use_gemini_posts = gr.Checkbox(value=True, label="Generate Posts with Gemini")
+            use_gemini_analysis = gr.Checkbox(value=False, label="Use Gemini for Sentiment (else HF)")
+
+            run_btn = gr.Button("🔎 Run Analysis", variant="primary")
+
+            status = gr.Markdown("Ready.")
+            stats_row = gr.Markdown("", visible=False)
+
+        with gr.Column(scale=7, elem_classes=["card"]):
+            posts_table = gr.Dataframe(
+                headers=["Post", "Sentiment", "Confidence"], wrap=True, height=420, interactive=False
+            )
+            plot = gr.Plot(label="Visualization")
+
+    hidden_engine = gr.State(value="—")
+    hidden_gemini_count = gr.State(value=0)
+    hidden_fallback_count = gr.State(value=0)
+
+    def _status_text(status_str, engine, gcount, fcount):
+        stats_md = f"""
+<span class="status-badge">🔧 Engine: <b>{engine}</b></span>
+<span class="status-badge">✨ Gemini posts: <b>{gcount}</b></span>
+<span class="status-badge">🧩 Fallback posts: <b>{fcount}</b></span>
+"""
+        return gr.update(value=f"**{status_str}**"), gr.update(value=stats_md, visible=True)
 
     run_btn.click(
         fn=run_analysis,
-        inputs=[hashtag, n_posts, vis_type, use_gemini],
-        outputs=[output_table, output_plot, source_label]
+        inputs=[hashtag, n_posts, vis_type, use_gemini_posts, use_gemini_analysis],
+        outputs=[posts_table, plot, status, hidden_engine, hidden_gemini_count, hidden_fallback_count]
+    ).then(
+        fn=_status_text,
+        inputs=[status, hidden_engine, hidden_gemini_count, hidden_fallback_count],
+        outputs=[status, stats_row]
     )
 
-# -----------------------------
-# Launch App
-# -----------------------------
+# ------------------ Launch ------------------
 if __name__ == "__main__":
     demo.launch()