Update app.py

app.py

@@ -1,127 +1,249 @@
 import os
 import random
-import streamlit as st
-import pandas as pd
-import plotly.express as px
+import time
+from typing import List, Dict
+
+from flask import Flask, jsonify, request, render_template
+from flask_cors import CORS
+
 import google.generativeai as genai
 from transformers import pipeline
 
-# ========== API KEYS ==========
-genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
-sentiment_pipeline = pipeline("sentiment-analysis")
+# -----------------------
+# Flask setup
+# -----------------------
+app = Flask(__name__, static_folder="static", template_folder="templates")
+CORS(app)
 
-# ========== POST GENERATOR ==========
-def generate_posts(hashtag, n=20):
-    """Try Gemini first, fallback to HuggingFace generated posts"""
-    posts = []
-    source = "Gemini"
+# -----------------------
+# Config & Environment
+# -----------------------
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
+if GOOGLE_API_KEY:
+    genai.configure(api_key=GOOGLE_API_KEY)
+
+# Cap posts
+MAX_POSTS = 50
+DEFAULT_POSTS = 20
+
+# -----------------------
+# Sentiment Analyzer (HF)
+# -----------------------
+# Pin a specific model for stability (avoid the production warning)
+SENTIMENT_MODEL = "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+sentiment_analyzer = pipeline(
+    "sentiment-analysis",
+    model=SENTIMENT_MODEL,
+    device=-1  # CPU
+)
 
+# -----------------------
+# Helpers
+# -----------------------
+def normalize_count(n: int) -> int:
     try:
-        prompt = f"Generate {n} realistic, diverse, short social media posts about {hashtag}. Use emojis."
-        response = genai.GenerativeModel("gemini-1.5-flash").generate_content(prompt)
-        text = response.text.strip().split("\n")
-        posts = [t for t in text if len(t.strip()) > 0][:n]
+        n = int(n)
     except Exception:
-        source = "HuggingFace"
-        base_posts = [
-            f"{hashtag} is the best thing ever 🎉",
-            f"I'm disappointed with {hashtag} 💔",
-            f"Not sure how I feel about {hashtag} 🤔",
-            f"Super excited about {hashtag} 🔥",
-            f"People are talking about {hashtag} everywhere 🌍",
-            f"{hashtag} totally failed expectations 😠",
-            f"I love {hashtag}! It's amazing ❤️",
-        ]
-        posts = random.choices(base_posts, k=n)
-
-    return posts, source
-
-# ========== SENTIMENT ANALYSIS ==========
-def analyze_posts(posts):
-    results = sentiment_pipeline(posts)
-    data = []
-    for post, res in zip(posts, results):
-        data.append({
-            "Post": post,
-            "Sentiment": res["label"],
-            "Confidence": round(res["score"], 2)
-        })
-    return pd.DataFrame(data)
-
-# ========== STREAMLIT UI ==========
-st.set_page_config(
-    page_title="AI Sentiment Analyzer",
-    page_icon="📊",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+        n = DEFAULT_POSTS
+    n = max(1, min(MAX_POSTS, n))
+    return n
 
-st.markdown(
-    """
-    <style>
-    body {
-        background: linear-gradient(135deg, #0f2027, #203a43, #2c5364);
-        color: white;
-    }
-    .stButton button {
-        background: linear-gradient(45deg, #ff6b6b, #f7b733);
-        color: white;
-        font-weight: bold;
-        border-radius: 12px;
-        padding: 10px 20px;
-        transition: 0.3s;
-    }
-    .stButton button:hover {
-        transform: scale(1.05);
-        background: linear-gradient(45deg, #36d1dc, #5b86e5);
-    }
-    .moving {
-        animation: float 3s ease-in-out infinite;
-    }
-    @keyframes float {
-        0% { transform: translatey(0px); }
-        50% { transform: translatey(-10px); }
-        100% { transform: translatey(0px); }
+def parse_sentiment(label: str, score: float) -> Dict[str, str]:
+    # Standardize to POSITIVE / NEGATIVE / NEUTRAL (distilbert gives POSITIVE/NEGATIVE)
+    if label.upper() == "POSITIVE":
+        sentiment = "POSITIVE"
+    elif label.upper() == "NEGATIVE":
+        sentiment = "NEGATIVE"
+    else:
+        sentiment = "NEUTRAL"
+    return {"sentiment": sentiment, "score": float(score)}
+
+def compute_aggregate(rows: List[Dict]) -> Dict:
+    pos = sum(1 for r in rows if r["sentiment"] == "POSITIVE")
+    neg = sum(1 for r in rows if r["sentiment"] == "NEGATIVE")
+    neu = sum(1 for r in rows if r["sentiment"] == "NEUTRAL")
+
+    total = max(1, len(rows))
+    pos_pct = round(100 * pos / total, 2)
+    neg_pct = round(100 * neg / total, 2)
+    neu_pct = round(100 * neu / total, 2)
+
+    # Rolling sentiment (simple EMA-like)
+    rolling = []
+    score_map = {"POSITIVE": 1.0, "NEUTRAL": 0.5, "NEGATIVE": 0.0}
+    alpha = 0.2
+    ema = 0.5
+    for r in rows:
+        ema = alpha * score_map[r["sentiment"]] + (1 - alpha) * ema
+        rolling.append(round(ema, 3))
+
+    return {
+        "counts": {"positive": pos, "negative": neg, "neutral": neu, "total": total},
+        "percent": {"positive": pos_pct, "negative": neg_pct, "neutral": neu_pct},
+        "rolling": rolling,
     }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
 
-st.title("🚀 Social Media Sentiment Analyzer")
-st.markdown("### Stream posts • Analyze moods • Visualize trends with animations")
+# -----------------------
+# Synthetic fallback posts (no external calls)
+# -----------------------
+FALLBACK_PATTERNS_POS = [
+    "Absolutely loving {tag} right now! 🔥",
+    "{tag} campaign is the best thing this season 🎉",
+    "I love {tag}! It's amazing ❤️",
+    "People are talking about {tag} everywhere 🌍",
+    "Super excited about {tag} 🙌",
+]
+FALLBACK_PATTERNS_NEG = [
+    "{tag} totally failed expectations 😠",
+    "I'm disappointed with {tag} 💔",
+    "{tag} needs serious improvements…",
+    "Not impressed by {tag} this time 😕",
+]
+FALLBACK_PATTERNS_NEU = [
+    "People are discussing {tag} a lot 🤔",
+    "Not sure how I feel about {tag} yet…",
+    "{tag} is trending — thoughts?",
+    "Mixed opinions around {tag}.",
+]
 
-# Sidebar
-st.sidebar.header("⚙️ Controls")
-hashtag = st.sidebar.text_input("Enter Hashtag", "#gla")
-num_posts = st.sidebar.slider("Number of Posts", 5, 50, 20)
-vis_type = st.sidebar.selectbox("Choose Visualization", ["Bar", "Pie", "Line"])
+def make_fallback_posts(hashtag: str, n: int) -> List[str]:
+    tag = hashtag if hashtag.startswith("#") else f"#{hashtag}"
+    posts = []
+    for _ in range(n):
+        bucket = random.choices(
+            [FALLBACK_PATTERNS_POS, FALLBACK_PATTERNS_NEU, FALLBACK_PATTERNS_NEG],
+            weights=[0.4, 0.35, 0.25],
+            k=1
+        )[0]
+        txt = random.choice(bucket).format(tag=tag)
+        posts.append(txt)
+    return posts
 
-if st.sidebar.button("🔍 Run Analysis"):
-    with st.spinner("Generating posts and analyzing sentiments..."):
-        posts, source = generate_posts(hashtag, num_posts)
-        df = analyze_posts(posts)
+# -----------------------
+# Gemini generation
+# -----------------------
+def generate_with_gemini(hashtag: str, n: int) -> List[str]:
+    """
+    Generate up to n short social posts using Gemini 2.0 Flash.
+    Returns list of strings. If API missing or error occurs, raises Exception.
+    """
+    if not GOOGLE_API_KEY:
+        raise RuntimeError("GOOGLE_API_KEY not set")
 
-    st.success(f"✅ Posts generated by **{source}** | Total: {len(posts)}")
+    model = genai.GenerativeModel("gemini-2.0-flash")
+    tag = hashtag if hashtag.startswith("#") else f"#{hashtag}"
 
-    st.dataframe(df, use_container_width=True)
+    prompt = f"""
+You are generating short, natural social posts (Twitter/Instagram style) about the topic {tag}.
+Rules:
+- Return exactly {n} posts.
+- One post per line.
+- Each post under 120 characters.
+- Use a mix of positive, neutral, and critical tones.
+- Avoid any hate speech, harassment, or slurs.
+- Do NOT include numbering like "1." or "-".
+- Do NOT wrap in code blocks.
+- Language: English.
 
-    # ===== VISUALIZATIONS =====
-    if vis_type == "Bar":
-        fig = px.bar(df, x="Sentiment", color="Sentiment", title=f"Sentiment Distribution for {hashtag}", animation_frame=None)
-    elif vis_type == "Pie":
-        fig = px.pie(df, names="Sentiment", title=f"Sentiment Share for {hashtag}", hole=0.4)
-    else:
-        fig = px.line(df, y="Confidence", title=f"Confidence Trend for {hashtag}")
-
-    st.plotly_chart(fig, use_container_width=True)
-
-    # ===== Moving 3D-like floating animation =====
-    st.markdown(
-        f"""
-        <div class="moving" style="font-size:24px; text-align:center; margin-top:30px;">
-        🌍 🔥 ❤️ 🎉 Trending Vibes around <b>{hashtag}</b>
-        </div>
-        """,
-        unsafe_allow_html=True
-    )
+Output format:
+<post 1>
+<post 2>
+...
+<post {n}>
+"""
+
+    # Simple retry to avoid transient errors
+    tries = 2
+    for i in range(tries):
+        try:
+            r = model.generate_content(prompt)
+            text = (r.text or "").strip()
+            if not text:
+                raise RuntimeError("Empty response from Gemini")
+
+            lines = [ln.strip() for ln in text.split("\n") if ln.strip()]
+            # Keep only the first n lines; also handle if Gemini returns more or fewer lines
+            if len(lines) < n:
+                # pad with fallback to hit n
+                lines += make_fallback_posts(hashtag, n - len(lines))
+            posts = lines[:n]
+            return posts
+        except Exception as e:
+            if i == tries - 1:
+                raise
+            time.sleep(0.8)  # brief backoff
+
+# -----------------------
+# API: analyze
+#   Request JSON:
+#     { "hashtag": "gla", "count": 30 }
+# -----------------------
+@app.route("/api/analyze", methods=["POST"])
+def analyze():
+    data = request.get_json(silent=True) or {}
+    hashtag = (data.get("hashtag") or "").strip()
+    count = normalize_count(data.get("count") or DEFAULT_POSTS)
+
+    if not hashtag:
+        return jsonify({"error": "hashtag is required"}), 400
+
+    posts: List[Dict] = []
+    gemini_count = 0
+    fallback_count = 0
+
+    # Try Gemini first; if it fails, fall back fully.
+    try:
+        gemini_posts = generate_with_gemini(hashtag, count)
+        for p in gemini_posts:
+            posts.append({"text": p, "source": "gemini"})
+        gemini_count = len(gemini_posts)
+    except Exception:
+        fb = make_fallback_posts(hashtag, count)
+        for p in fb:
+            posts.append({"text": p, "source": "fallback"})
+        fallback_count = len(fb)
+
+    # Sentiment analysis
+    rows = []
+    for p in posts:
+        res = sentiment_analyzer(p["text"])[0]  # {'label': 'POSITIVE', 'score': 0.99}
+        parsed = parse_sentiment(res["label"], res["score"])
+        rows.append({
+            "text": p["text"],
+            "source": p["source"],
+            "sentiment": parsed["sentiment"],
+            "score": parsed["score"],
+        })
+
+    agg = compute_aggregate(rows)
+
+    return jsonify({
+        "meta": {
+            "hashtag": hashtag if hashtag.startswith("#") else f"#{hashtag}",
+            "requested": count,
+            "generated_by": {
+                "gemini": gemini_count,
+                "fallback": fallback_count
+            },
+            "model": {
+                "generation": "gemini-2.0-flash" if gemini_count > 0 else "fallback-templates",
+                "sentiment": SENTIMENT_MODEL
+            }
+        },
+        "rows": rows,
+        "aggregate": agg
+    }), 200
+
+# -----------------------
+# UI Route
+# -----------------------
+@app.route("/", methods=["GET"])
+def home():
+    return render_template("index.html")
+
+# -----------------------
+# Entrypoint
+# -----------------------
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "7860"))
+    app.run(host="0.0.0.0", port=port, debug=False)