Update app.py

app.py

@@ -1,430 +1,145 @@
-# 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 pandas as pd
 import plotly.express as px
+from transformers import pipeline
+import google.generativeai as genai
 
-# --- 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 -----------------
+# Load Gemini API key from environment secrets
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 
-# ------------------ Config ------------------
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+    gemini_model = genai.GenerativeModel("gemini-1.5-flash")
+else:
+    gemini_model = None
 
-MAX_POSTS = 50
-DEFAULT_MODEL_HF = "distilbert-base-uncased-finetuned-sst-2-english"
-GEMINI_MODEL_FAST = "gemini-1.5-flash"
+# Hugging Face sentiment pipeline
+sentiment_pipeline = pipeline("sentiment-analysis")
 
-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)
-
-
-# ------------------ 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] = []
+# ----------------- FUNCTIONS -----------------
+def generate_posts(hashtag: str, num_posts: int, use_gemini: bool):
+    posts = []
+    source = "huggingface"
 
-    # Try JSON array
-    if text.startswith("["):
+    if use_gemini and gemini_model:
+        prompt = f"Generate {num_posts} realistic social media posts about {hashtag}. Use emojis. Tone should vary (positive, negative, neutral)."
         try:
-            arr = json.loads(text)
-            if isinstance(arr, list):
-                posts = [str(x).strip() for x in arr]
+            response = gemini_model.generate_content(prompt)
+            text = response.text
+            posts = [line.strip("-• ") for line in text.split("\n") if line.strip()][:num_posts]
+            source = "gemini"
+        except Exception as e:
+            posts = [f"⚠️ Gemini API failed: {e}. Falling back to Hugging Face."]
+            source = "huggingface"
+
+    if not posts:  # fallback
+        template = [
+            f"Not sure how I feel about {hashtag} 🤔",
+            f"{hashtag} totally failed expectations 😠",
+            f"People are talking about {hashtag} everywhere 🌍",
+            f"{hashtag} campaign is the best thing this year 🎉",
+            f"I'm disappointed with {hashtag} 💔",
+            f"Super excited about {hashtag} 🔥",
+            f"I love {hashtag}! It's amazing ❤️",
+        ]
+        posts = random.choices(template, k=num_posts)
+
+    return posts, source
+
+
+def analyze_sentiments(hashtag, num_posts, visualization, use_gemini):
+    num_posts = min(num_posts, 50)  # cap at 50
+
+    posts, source = generate_posts(hashtag, num_posts, use_gemini)
+
+    results = []
+    for post in posts:
+        try:
+            result = sentiment_pipeline(post[:512])[0]
+            results.append((post, result["label"], round(result["score"], 2)))
         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} 💔",
-        f"{hashtag} totally failed expectations 😠",
-        f"Not sure how I feel about {hashtag} 🤔",
-        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"Mixed feelings about {hashtag} today 😶‍🌫️",
-        f"Curious where {hashtag} goes next 👀",
-    ]
-    # 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:
-        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:
-        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],
-    })
-
-    # 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
-
-
-# ------------------ 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",
-)
-
+            results.append((post, "NEUTRAL", 0.5))
+
+    # Visualization
+    sentiments = [r[1] for r in results]
+    fig = None
+    if visualization == "Bar":
+        fig = px.bar(x=sentiments, title=f"Sentiment Distribution for {hashtag}", labels={"x": "Sentiment", "y": "Count"})
+    elif visualization == "Pie":
+        fig = px.pie(names=sentiments, title=f"Sentiment Share for {hashtag}")
+    elif visualization == "Line":
+        fig = px.line(y=[1 if s == "POSITIVE" else -1 if s == "NEGATIVE" else 0 for s in sentiments],
+                      title=f"Sentiment Rolling Trend for {hashtag}")
+
+    summary_text = f"✅ Posts generated by **{source.upper()}**\nTotal Posts: {len(results)}"
+    return results, fig, summary_text
+
+# ----------------- UI -----------------
 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;
+#col-left {
+  background: rgba(25, 25, 25, 0.85);
+  padding: 20px;
+  border-radius: 16px;
+  box-shadow: 0 0 20px rgba(0,0,0,0.4);
+  animation: fadeInLeft 1s ease;
 }
-.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;
+#col-right {
+  background: rgba(15, 15, 15, 0.85);
+  padding: 20px;
+  border-radius: 16px;
+  box-shadow: 0 0 20px rgba(0,0,0,0.4);
+  animation: fadeInRight 1s ease;
 }
-@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;
+.posts-table {
+  max-height: 420px;
+  overflow-y: auto;
 }
-@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;
+@keyframes fadeInLeft {
+  from {opacity: 0; transform: translateX(-30px);}
+  to {opacity: 1; transform: translateX(0);}
 }
-.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)
+@keyframes fadeInRight {
+  from {opacity: 0; transform: translateX(30px);}
+  to {opacity: 1; transform: translateX(0);}
+}
+button {
+  transition: all 0.2s ease;
+}
+button:hover {
+  transform: scale(1.05);
+  box-shadow: 0 0 12px #ff6600;
 }
 """
 
-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.Blocks(css=CUSTOM_CSS, theme=gr.themes.Soft()) as demo:
+    gr.HTML("<h1 style='text-align:center; color:#FF6600;'>🚀 Social Media Sentiment Analyzer</h1>")
+    gr.HTML("<p style='text-align:center;'>Stream posts • Analyze moods • Visualize trends</p>")
 
     with gr.Row():
-        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"]):
+        with gr.Column(elem_id="col-left"):
+            hashtag = gr.Textbox(label="Enter Hashtag", value="#gla")
+            num_posts = gr.Slider(5, 50, value=20, step=1, label="Number of Posts")
+            visualization = gr.Dropdown(choices=["Bar", "Pie", "Line"], value="Bar", label="Choose Visualization")
+            use_gemini = gr.Checkbox(label="Use Gemini Advanced Analysis", value=False)
+            run_btn = gr.Button("🔍 Run Analysis", variant="primary")
+
+        with gr.Column(elem_id="col-right"):
             posts_table = gr.Dataframe(
-                headers=["Post", "Sentiment", "Confidence"], wrap=True, height=420, interactive=False
+                headers=["Post", "Sentiment", "Confidence"],
+                interactive=False,
+                elem_classes=["posts-table"]
             )
-            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)
+            plot_out = gr.Plot()
+            summary = gr.Markdown()
 
     run_btn.click(
-        fn=run_analysis,
-        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]
+        analyze_sentiments,
+        inputs=[hashtag, num_posts, visualization, use_gemini],
+        outputs=[posts_table, plot_out, summary]
     )
 
-# ------------------ Launch ------------------
+# ----------------- MAIN -----------------
 if __name__ == "__main__":
     demo.launch()