Update app.py

app.py

@@ -5,7 +5,7 @@ import stanza
 import pandas as pd
 import re
 import docx
-from collections import Counter, defaultdict
+from collections import Counter
 from transformers import pipeline
 import torch
 from langdetect import detect
@@ -13,22 +13,8 @@ import streamlit as st
 import io
 from newspaper import Article
 import concurrent.futures
-import urllib.parse
-import requests
-
-# optional TF-IDF for better SEO keyword extraction
-try:
-    from sklearn.feature_extraction.text import TfidfVectorizer
-    SKLEARN_AVAILABLE = True
-except Exception:
-    SKLEARN_AVAILABLE = False
-
-# optional: pytrends (for Google Trends signals). Best-effort.
-try:
-    from pytrends.request import TrendReq
-    PYTRENDS_AVAILABLE = True
-except Exception:
-    PYTRENDS_AVAILABLE = False
+import json
+import tempfile
 
 # ===============================
 # 🔑 Vertex AI Setup
@@ -36,9 +22,6 @@ except Exception:
 import vertexai
 from vertexai.preview.generative_models import GenerativeModel
 
-import json
-import tempfile
-
 # Ensure GCP credentials exist
 if "GCP_SERVICE_ACCOUNT_JSON" not in os.environ:
     raise RuntimeError("❌ GCP_SERVICE_ACCOUNT_JSON secret not found in Hugging Face Space")
@@ -146,12 +129,9 @@ def read_and_split_articles(file_path):
         if not text:
             continue
 
-        # If this paragraph contains bold run(s), keep as separate paragraph/subhead
-        try:
-            is_bold = any([r.bold for r in para.runs]) if para.runs else False
-        except Exception:
-            is_bold = False
-        paragraphs.append(text)
+        # If this paragraph contains bold run(s), keep it as its own paragraph (likely a subhead)
+        is_bold = any([r.bold for r in para.runs]) if para.runs else False
+        paragraphs.append(text if not is_bold else text)
 
     headline = paragraphs[0] if paragraphs else ""
     body_paragraphs = paragraphs[1:] if len(paragraphs) > 1 else []
@@ -159,54 +139,23 @@ def read_and_split_articles(file_path):
     return headline, body_paragraphs
 
 # ===============================
-# URL Reader (robust)
+# Robust URL Reader
 # ===============================
 def read_article_from_url(url):
-    """
-    Robust article fetcher:
-    - sanitizes/unquotes the URL
-    - tries a direct requests.get() with a browser UA and feeds HTML to newspaper.Article
-    - falls back to Article.download() only if necessary
-    - returns (headline, body_paragraphs) or ("", []) on failure
-    """
+    # safe-guard trailing spaces and encoded spaces
     if not url or not isinstance(url, str):
         return "", []
-
-    # sanitize and normalize url
     url = url.strip()
-    url = urllib.parse.unquote(url)
-    url = url.rstrip(" \t\n\r")
-    url = url.replace(" ", "")
-
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
-                      "(KHTML, like Gecko) Chrome/115.0 Safari/537.36"
-    }
-
+    # try to download & parse
     try:
-        # try direct fetch first (some sites block Article.download())
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200 and resp.text.strip():
-            art = Article(url)
-            # feed html to newspaper if possible
-            try:
-                art.set_html(resp.text)
-                art.parse()
-            except Exception:
-                # fallback to normal download
-                art.download()
-                art.parse()
-        else:
-            # fallback to library download (may raise)
-            art = Article(url)
-            art.download()
-            art.parse()
+        article = Article(url)
+        article.download()
+        article.parse()
     except Exception as e:
-        st.warning(f"⚠️ Could not download/parse article ({e}). Returning empty result.")
+        st.warning(f"⚠️ Could not download article: {e}")
         return "", []
-
-    headline = art.title.strip() if art.title else ""
-    text_body = art.text.strip() if art.text else ""
+    headline = article.title.strip() if article.title else ""
+    text_body = article.text.strip() if article.text else ""
     body_paragraphs = [p.strip() for p in text_body.split("\n") if p.strip()]
     return headline, body_paragraphs
 
@@ -215,20 +164,19 @@ def read_article_from_url(url):
 # ===============================
 def filter_neutral(emotion_results, neutral_threshold=0.75):
     sorted_results = sorted(emotion_results, key=lambda x: x["score"], reverse=True)
-
     scores = {}
     for r in sorted_results:
         scores[r["label"]] = round(r["score"], 3)
-
     if "neutral" in scores and scores["neutral"] > neutral_threshold:
         scores.pop("neutral")
-
     return scores
 
 # ===============================
 # Split Sentences
 # ===============================
 def split_sentences(text, lang):
+    if not text:
+        return []
     if lang == "hi":
         sentences = re.split(r"।", text)
         return [s.strip() for s in sentences if s.strip()]
@@ -268,21 +216,129 @@ def get_pos_tags(sentence, lang):
 def normalize_scores(scores: dict):
     if not scores:
         return scores
-
     max_val = max(scores.values())
     if max_val == 0:
         return scores
-
     normalized = {}
     for k, v in scores.items():
         normalized[k] = round(v / max_val, 3)
-
     return normalized
 
 # ===============================
-# Stronger paragraph cleaning (merge bullets/numbers & skip promos)
+# Enhanced Keyword extraction for SEO suggestions
+# ===============================
+COMMON_STOPWORDS = set([
+    "the","a","an","and","or","in","on","to","of","for","is","it","that","this","with","its","as",
+    "are","be","was","were","by","from","at","have","has","had","but","not","which","who","what",
+    "when","where","why","how","will","can","should","our","we","you","your","I","they","their","his","her"
+])
+
+def extract_keywords(text, top_n=6):
+    # simple heuristic: words length > 3, not stopwords, prefer words appearing earlier & freq > 1
+    if not text:
+        return []
+    tokens = re.findall(r"\w+", text.lower())
+    tokens = [t for t in tokens if t not in COMMON_STOPWORDS and len(t) > 3]
+    freq = Counter(tokens)
+    if not freq:
+        return []
+    # prefer words that appear in first 80 chars (title/head) or start of article
+    head_tokens = set(re.findall(r"\w+", text[:200].lower()))
+    scored = []
+    for word, count in freq.items():
+        score = count
+        if word in head_tokens:
+            score += 1.25
+        scored.append((word, score))
+    scored.sort(key=lambda x: x[1], reverse=True)
+    keywords = [w for w,_ in scored[:top_n]]
+    return keywords
+
+def shorten_headline_variants(headline):
+    # provide 1-3 short headline ideas (heuristic)
+    words = headline.split()
+    variants = []
+    # variant 1: take first 6-8 words
+    variants.append(" ".join(words[:8]) + ("..." if len(words) > 8 else ""))
+    # variant 2: main noun + core keyword (if any)
+    kws = extract_keywords(headline, top_n=3)
+    if kws:
+        variants.append(f"{kws[0].capitalize()}: {words[0]} {' '.join(words[1:4])}")
+    # unique variant fallback: remove stopwords from headline
+    variants.append(" ".join([w for w in words if w.lower() not in COMMON_STOPWORDS])[:70])
+    # dedupe & cleanup
+    clean = []
+    for v in variants:
+        v = v.strip()
+        if v and v not in clean:
+            clean.append(v)
+    return clean[:3]
+
+# ===============================
+# Compute SEO suggestions (single place; lightweight heuristics)
+# ===============================
+def compute_seo_suggestions_enhanced(headline, paragraphs, top_n_keywords=5):
+    """
+    Returns small dict:
+    {
+      "keywords": [...],
+      "keyword_density": {...},
+      "suggestions": [...],
+      "headline_suggestions": [...]
+    }
+    Show main SEO block only once (headline area).
+    """
+    text = (headline or "") + " " + " ".join(paragraphs or [])
+    tokens = re.findall(r"\w+", text.lower())
+    tokens = [t for t in tokens if t not in COMMON_STOPWORDS and len(t) > 3]
+    freq = Counter(tokens)
+    total = sum(freq.values()) or 1
+    # pick top keywords but filter random garbage by requiring either freq>1 or appearing in headline
+    top = []
+    for w, c in freq.most_common(30):
+        if c > 1 or (headline and w in headline.lower()):
+            top.append((w, c))
+        if len(top) >= top_n_keywords:
+            break
+    keywords = [k for k,_ in top]
+    keyword_density = {k: round(freq[k] / total, 4) for k in keywords}
+    suggestions = []
+    # headline length advice
+    if headline:
+        if len(headline) > 70:
+            suggestions.append("Headline is long (>70 chars). Consider shortening to 50–65 chars for better CTR.")
+        elif len(headline) < 30:
+            suggestions.append("Headline is short (<30 chars). Consider adding a descriptive keyword for clarity/SEO.")
+    # keyword placement
+    if keywords:
+        suggestions.append(f"Primary keywords to consider: {', '.join(keywords)}.")
+        # ensure at least one primary keyword in first 100 chars
+        head_sample = text[:100].lower()
+        if not any(k in head_sample for k in keywords[:2]):
+            suggestions.append("Consider including 1–2 primary keywords in the headline or first 100 words.")
+        # density advice (only sensible extremes)
+        for k, d in keyword_density.items():
+            if d < 0.003:
+                suggestions.append(f"Keyword '{k}' has low density ({d}). Consider using it once in the first 100 words.")
+            elif d > 0.06:
+                suggestions.append(f"Keyword '{k}' has high density ({d}). Review for possible keyword stuffing.")
+    # meta draft
+    body_tokens = [t for t in tokens]
+    meta = " ".join(body_tokens[:25])[:155].strip()
+    suggestions.append(f"Suggested meta (draft): {meta}...")
+    # headline ideas
+    headline_suggestions = shorten_headline_variants(headline) if headline else []
+    return {"keywords": keywords, "keyword_density": keyword_density, "suggestions": suggestions, "headline_suggestions": headline_suggestions}
+
+# ===============================
+# Improved Paragraph Cleaner
 # ===============================
 def clean_paragraphs(paragraphs):
+    """
+    - Merge bullets and numbered lists with previous paragraphs.
+    - Remove promotional or repetitive boilerplate.
+    - Detect and merge short fragments into previous paragraph.
+    """
     cleaned = []
     prev = None
 
@@ -326,213 +382,6 @@ def clean_paragraphs(paragraphs):
 
     return cleaned
 
-# ===============================
-# SEO / Keyword extraction helpers (TF-IDF + spaCy NER/POS)
-# ===============================
-SEO_STOPWORDS = set([
-    "the","a","an","and","or","in","on","to","of","for","is","it","that","this","with","its","as",
-    "are","was","were","be","by","from","at","has","have","but","not","will","can","which","also",
-    "we","you","i","they","their","our","us"
-])
-
-def extract_candidate_keywords(headline, paragraphs, top_k=10, ngram_range=(1,2)):
-    """
-    Return a ranked list of candidate keywords using TF-IDF + POS/NER filtering.
-    Prioritizes named entities and multi-word noun phrases.
-    """
-    text = " ".join([headline] + paragraphs)
-    if not text.strip():
-        return []
-
-    if not SKLEARN_AVAILABLE:
-        # fallback: naive frequency filtered by spaCy nouns/ents
-        try:
-            doc_sp = nlp_en(text)
-        except Exception:
-            tokens = re.findall(r"\w+", text.lower())
-            tokens = [t for t in tokens if t not in SEO_STOPWORDS and len(t) > 2]
-            freq = Counter(tokens)
-            return [(k, v) for k, v in freq.most_common(top_k)]
-
-        ne_set = set(ent.text.strip() for ent in doc_sp.ents if len(ent.text.strip()) > 2)
-        candidate_terms = defaultdict(float)
-        for ne in ne_set:
-            candidate_terms[ne] += 3.0
-        for chunk in doc_sp.noun_chunks:
-            txt = chunk.text.strip()
-            if len(txt) > 2:
-                candidate_terms[txt] += 0.5
-        for tok in doc_sp:
-            if tok.pos_ in ("NOUN", "PROPN") and not tok.is_stop and tok.is_alpha:
-                candidate_terms[tok.text] += 0.1
-        cand_list = sorted(candidate_terms.items(), key=lambda x: x[1], reverse=True)[:top_k]
-        return cand_list
-
-    # Use TF-IDF
-    vectorizer = TfidfVectorizer(
-        ngram_range=ngram_range,
-        stop_words='english',
-        max_df=0.9,
-        min_df=1,
-        token_pattern=r"(?u)\b\w\w+\b"
-    )
-    try:
-        X = vectorizer.fit_transform([text])
-        feature_names = vectorizer.get_feature_names_out()
-        scores = X.toarray().sum(axis=0)
-        terms_scores = {feature_names[i]: float(scores[i]) for i in range(len(feature_names))}
-    except Exception:
-        return []
-
-    # spaCy analysis
-    try:
-        doc_sp = nlp_en(text)
-    except Exception:
-        # fallback to top tfidf raw
-        cleaned = [(t, s) for t, s in terms_scores.items() if t.lower() not in SEO_STOPWORDS and len(t) > 2]
-        cleaned = sorted(cleaned, key=lambda x: x[1], reverse=True)[:top_k]
-        return cleaned
-
-    candidate_terms = defaultdict(float)
-
-    # prioritize named entities
-    for ent in doc_sp.ents:
-        ent_text = ent.text.strip()
-        if len(ent_text) > 2:
-            key = ent_text
-            # try to find matching tfidf key(s)
-            tf_score = 0.0
-            for tfk, sc in terms_scores.items():
-                if ent_text.lower() in tfk:
-                    tf_score += sc
-            candidate_terms[key] += tf_score + 2.0
-
-    # noun chunks and noun/proper tokens
-    for chunk in doc_sp.noun_chunks:
-        chunk_text = chunk.text.strip()
-        if len(chunk_text) > 2 and not all(w.lower() in SEO_STOPWORDS for w in chunk_text.split()):
-            candidate_terms[chunk_text] += terms_scores.get(chunk_text.lower(), 0.0) + 0.2
-
-    for token in doc_sp:
-        if token.pos_ in ("NOUN", "PROPN") and not token.is_stop and token.is_alpha and len(token.text) > 2:
-            t = token.text.strip()
-            candidate_terms[t] += terms_scores.get(t.lower(), 0.0) + 0.05
-
-    if not candidate_terms:
-        cleaned = [(t, s) for t, s in terms_scores.items() if t.lower() not in SEO_STOPWORDS and len(t) > 2]
-        cleaned = sorted(cleaned, key=lambda x: x[1], reverse=True)[:top_k]
-        return cleaned
-
-    cand_list = sorted(candidate_terms.items(), key=lambda x: x[1], reverse=True)
-    # dedupe case-insensitive and prune
-    seen = set()
-    final = []
-    for term, score in cand_list:
-        low = term.lower()
-        if low in seen:
-            continue
-        if len(low) < 3:
-            continue
-        if all(tok in SEO_STOPWORDS for tok in low.split()):
-            continue
-        final.append((term, round(score, 4)))
-        seen.add(low)
-        if len(final) >= top_k:
-            break
-
-    return final
-
-def query_google_trends(keyword):
-    """
-    Best-effort Google Trends interest check for a keyword.
-    Returns a float score (0-100) or None if not available.
-    Requires pytrends and network.
-    """
-    if not PYTRENDS_AVAILABLE:
-        return None
-    try:
-        py = TrendReq(hl='en-US', tz=360)
-        kw_list = [keyword]
-        py.build_payload(kw_list, timeframe='today 12-m')
-        data = py.interest_over_time()
-        if data.empty:
-            return None
-        mean_interest = float(data[keyword].mean())
-        return mean_interest
-    except Exception:
-        return None
-
-def compute_seo_suggestions_enhanced(headline, paragraphs, top_k=6):
-    """
-    Returns:
-    {
-      keywords: [{'term':str, 'score':float, 'trend':float|None}, ...],
-      headline_suggestions: [<string>, ...],
-      suggestions: [<human-friendly advice>...]
-    }
-    """
-    body_text = " ".join(paragraphs)
-    candidates = extract_candidate_keywords(headline, paragraphs, top_k=20)
-
-    keywords = []
-    for term, score in candidates:
-        trend = None
-        if PYTRENDS_AVAILABLE:
-            try:
-                trend = query_google_trends(term if isinstance(term, str) else term[0])
-            except Exception:
-                trend = None
-        keywords.append({"term": term, "score": score, "trend": trend})
-
-    suggestions = []
-    # headline length advice
-    hlen = len(headline)
-    if hlen > 70:
-        suggestions.append("Headline is long (>70 chars). Consider shortening to 50–65 characters for better CTR.")
-    elif hlen < 30:
-        suggestions.append("Headline is short (<30 chars). Consider adding a descriptive primary keyword for clarity.")
-
-    prioritized = sorted(keywords, key=lambda x: (x["trend"] if x["trend"] is not None else -1, x["score"]), reverse=True)
-    top_terms = [k["term"] for k in prioritized[:3]]
-
-    if top_terms:
-        suggestions.append(f"Primary keywords to consider: {', '.join(top_terms)}. Try to include 1 in the headline and 1–2 in the first 100 words.")
-
-    # lightweight density checks
-    body_tokens = re.findall(r"\w+", body_text.lower())
-    total = max(1, len(body_tokens))
-    for k in top_terms:
-        freq = body_tokens.count(k.lower())
-        dens = freq / total
-        if dens < 0.002:
-            suggestions.append(f"Keyword '{k}' appears {freq} times — consider using it once near the top of the article to improve relevance.")
-        elif dens > 0.06:
-            suggestions.append(f"Keyword '{k}' density is high ({round(dens,3)}). Watch for keyword-stuffing.")
-
-    # headline rewrite suggestions (2 variations)
-    headline_suggestions = []
-    if top_terms:
-        primary = top_terms[0]
-        if primary.lower() not in headline.lower():
-            if ":" in headline:
-                h1 = headline.replace(":", f": {primary} —", 1)
-            else:
-                h1 = f"{headline} — {primary}"
-            if len(h1) <= 90:
-                headline_suggestions.append(h1)
-            else:
-                short = f"{primary}: {headline}"
-                headline_suggestions.append(short[:90])
-    if top_terms and not any(w in headline.lower() for w in ["how", "why", "what", "when", "where", "which", "?"]):
-        headline_suggestions.append(f"How {str(top_terms[0]).title()} Shapes the Story — {headline[:50]}")
-
-    result = {
-        "keywords": keywords[:top_k],
-        "headline_suggestions": headline_suggestions,
-        "suggestions": suggestions
-    }
-    return result
-
 # ===============================
 # Gemini Insight Generation (humanized prompts + gemini scoring + guardrails)
 # ===============================
@@ -542,7 +391,6 @@ def generate_insight(text, emotions, sentiment, level="Paragraph", emotion_pipel
     - Humanizes Gemini prompt and asks for Original → Rewrite → Why.
     - Re-scores Gemini's rewrite using local pipelines (emotion + sentiment).
     - Applies guardrails based on Gemini output (NOT original).
-    - Attaches lightweight SEO suggestions where helpful.
     - Returns gemini_emotions (top-3 dict) and final_text string for display.
     """
     try:
@@ -589,15 +437,17 @@ No rewrite needed. The {level.lower()} reads naturally and clearly.
 
         # If Gemini declines rewrite
         if response_text.startswith("No rewrite needed"):
+            # return clear "no rewrite" phrasing so editorial doesn't get scary warnings
             return {}, f"✅ No rewrite needed. The {level.lower()} reads naturally and clearly."
 
-        # Re-score Gemini output using a context (Original + Rewrite)
+        # Re-score Gemini output using a context (Original + Rewrite) so that emotion+sentiment reflect the suggested change
         gemini_emotions = {}
         gemini_sentiment = {}
         if emotion_pipeline is not None and sentiment_pipeline is not None:
             context_for_scoring = f"Original: {text}\nRewrite: {response_text}"
             emo_res_new = emotion_pipeline(context_for_scoring[:512])[0]
             gemini_emotions = filter_neutral(emo_res_new)
+            # keep top 3 emotions with scores
             sorted_emotions = sorted(gemini_emotions.items(), key=lambda x: x[1], reverse=True)
             gemini_emotions = dict(sorted_emotions[:3])
 
@@ -605,6 +455,7 @@ No rewrite needed. The {level.lower()} reads naturally and clearly.
             gemini_sentiment = max(senti_res_new, key=lambda x: x["score"])
 
             # Guardrails on GEMINI output:
+            # If Gemini's suggested rewrite itself is strongly negative, we skip (treat as no rewrite)
             if gemini_sentiment["label"].upper() == "NEGATIVE" and gemini_sentiment["score"] >= 0.8:
                 return {}, f"✅ No rewrite needed. The {level.lower()} reads naturally and clearly."
 
@@ -613,21 +464,26 @@ No rewrite needed. The {level.lower()} reads naturally and clearly.
                 if emo.lower() in negative_emotions and score >= 0.8:
                     return {}, f"✅ No rewrite needed. The {level.lower()} reads naturally and clearly."
 
+            # If both approval and disapproval are high in the gemini re-score, skip as ambiguous
             if gemini_emotions.get("approval", 0) > 0.6 and gemini_emotions.get("disapproval", 0) > 0.6:
                 return {}, f"✅ No rewrite needed. The {level.lower()} reads naturally and clearly."
 
-        # Attach SEO suggestions (lightweight) if possible for headline/paragraphs
-        seo_text = ""
+        # Attach SEO suggestions (lightweight) if possible (but minimal)
+        seo_tips = []
         try:
-            seo_data = compute_seo_suggestions_enhanced(text if level != "Headline" else text, [text])
-            if seo_data and seo_data.get("suggestions"):
-                seo_text = "\n\n💡 SEO Suggestions:\n- " + "\n- ".join(seo_data.get("suggestions", [])[:4])
+            seo_data = compute_seo_suggestions_enhanced(text, [text])
+            seo_tips = seo_data.get("suggestions", [])[:2]
         except Exception:
-            seo_text = ""
+            seo_tips = []
 
+        # Format the final output: show the Gemini rewrite + its sentiment + top-3 emotions
         gem_emo_text = ", ".join([f"{k}: {v}" for k, v in gemini_emotions.items()]) if gemini_emotions else "N/A"
         gem_sent_text = f"{gemini_sentiment.get('label','N/A')} ({round(gemini_sentiment.get('score',0),3)})" if gemini_sentiment else "N/A"
 
+        seo_text = ""
+        if seo_tips:
+            seo_text = "\n\n💡 SEO Suggestions:\n- " + "\n- ".join(seo_tips)
+
         final_text = (
             f"✍️ {response_text}\n\n"
             f"✨ Gemini Rewrite Sentiment: {gem_sent_text}\n"
@@ -664,19 +520,16 @@ def analyze_article(headline, paragraphs, lang, emotion_pipeline, sentiment_pipe
         st.write("Emotions →", headline_emotions)
         st.write("Sentiment →", headline_sentiment)
 
-        # enhanced SEO for headline
-        try:
-            seo_head = compute_seo_suggestions_enhanced(headline, paragraphs)
-            if seo_head.get("suggestions"):
-                st.write("💡 SEO Suggestions (headline):")
-                for s in seo_head["suggestions"]:
-                    st.write("-", s)
-            if seo_head.get("headline_suggestions"):
-                st.write("📝 Headline ideas:")
-                for hs in seo_head["headline_suggestions"]:
-                    st.write("-", hs)
-        except Exception:
-            pass
+        # Show SEO suggestions only once here
+        seo_data = compute_seo_suggestions_enhanced(headline, paragraphs)
+        if seo_data.get("suggestions"):
+            st.markdown("### 💡 SEO Suggestions (headline)")
+            for s in seo_data["suggestions"][:3]:
+                st.write("-", s)
+        if seo_data.get("headline_suggestions"):
+            st.markdown("### 📝 Headline ideas:")
+            for hs in seo_data["headline_suggestions"]:
+                st.write("-", hs)
 
         top3_headline, headline_insight = generate_insight(
             headline, headline_emotions, headline_sentiment, "Headline",
@@ -690,7 +543,7 @@ def analyze_article(headline, paragraphs, lang, emotion_pipeline, sentiment_pipe
         })
 
     # -----------------------
-    # Overall Article Analysis
+    # Overall Article Analysis (compute weighted emotions across cleaned paragraphs)
     # -----------------------
     if paragraphs:
         for p in paragraphs:
@@ -725,9 +578,17 @@ def analyze_article(headline, paragraphs, lang, emotion_pipeline, sentiment_pipe
         })
 
     # -----------------------
-    # Paragraph Analysis
+    # Paragraph Analysis (detect sub-headings and avoid SEO spam)
     # -----------------------
     for p_idx, para in enumerate(paragraphs, start=1):
+        # subheading heuristics
+        is_subheading = (
+            para.strip().endswith("?")
+            or len(para.split()) <= 8
+            or bool(re.match(r"^\d+[\.\)]", para.strip()))
+            or (sum(1 for w in para.split() if w.isupper()) >= 2 and len(para.split()) <= 10)
+        )
+
         para_counter, para_sentiments = Counter(), []
         sentences = split_sentences(para, lang[:2])
         for sentence in sentences:
@@ -742,28 +603,29 @@ def analyze_article(headline, paragraphs, lang, emotion_pipeline, sentiment_pipe
         sorted_para = sorted(para_emotions.items(), key=lambda x: x[1], reverse=True)
         para_emotions = dict(sorted_para[:10])
         para_sentiment = max(para_sentiments, key=lambda x: x["score"]) if para_sentiments else {}
-        st.subheader(f"📑 Paragraph {p_idx}")
+
+        st.subheader(f"{'🧩 Sub-heading' if is_subheading else '📑 Paragraph'} {p_idx}")
         st.write(para)
         st.write("Emotions →", para_emotions)
         st.write("Sentiment →", para_sentiment)
 
-        # paragraph-level SEO: show lightweight suggestions
-        try:
-            seo_para = compute_seo_suggestions_enhanced(para, [para])
-            if seo_para.get("suggestions"):
-                st.write("💡 SEO (paragraph):")
-                for s in seo_para["suggestions"]:
-                    st.write("-", s)
-        except Exception:
-            pass
+        # Show limited SEO only if NOT a sub-heading and only one focused tip
+        if not is_subheading:
+            try:
+                seo_data = compute_seo_suggestions_enhanced("", [para], top_n_keywords=3)
+                uniq_suggestion = seo_data["suggestions"][0] if seo_data.get("suggestions") else None
+                if uniq_suggestion:
+                    st.markdown(f"💡 SEO Tip: {uniq_suggestion}")
+            except Exception:
+                pass
 
         top3_para, insight = generate_insight(
-            para, para_emotions, para_sentiment, "Paragraph",
+            para, para_emotions, para_sentiment, "Sub-heading" if is_subheading else "Paragraph",
             emotion_pipeline=emotion_pipeline, sentiment_pipeline=sentiment_pipeline
         )
         st.write(insight)
         export_rows.append({
-            "Type": "Paragraph","Text": para,
+            "Type": "Sub-heading" if is_subheading else "Paragraph","Text": para,
             "Emotions": para_emotions,"Sentiment": para_sentiment,
             "Top3": dict(top3_para),"Insight": insight
         })
@@ -782,6 +644,7 @@ text_input = st.text_area("Or paste text here")
 if st.button("🔍 Analyze"):
     with st.spinner("Running analysis... ⏳"):
         if uploaded_file:
+            # streamlit FileUploader returns a BytesIO-like object; docx.Document accepts file-like
             headline, paragraphs = read_and_split_articles(uploaded_file)
         elif url_input.strip():
             headline, paragraphs = read_article_from_url(url_input)