Update app.py

app.py

@@ -1,12 +1,13 @@
 # imports
-import os
-import json
-import urllib.parse
-import concurrent.futures
+import re
+import typing
 import plotly.graph_objects as go
 import streamlit as st
-from groq import Groq
 from textblob import TextBlob
+import json
+import os
+import concurrent.futures
+from groq import Groq
 import textstat
 import trafilatura
 import requests
@@ -16,35 +17,14 @@ import nltk
 # constants
 MAX_WORDS = 400
 
-st.set_page_config(page_title="FrameVis | Media Framing", layout="wide")
+ARTICLE_A = """In a watershed moment for global tech governance, international regulatory bodies have introduced the comprehensive Artificial Intelligence Safeguard Act. For too long, Silicon Valley titans have operated in a wild west environment, prioritizing unchecked corporate greed and rapid deployment over public safety. This landmark legislation aims to establish rigorous ethical boundaries and mandatory safety audits before any advanced generative models can be released to the public. Proponents argue that without these essential guardrails, society faces catastrophic risks ranging from massive, unmitigated job displacement to the proliferation of deepfake-fueled misinformation that threatens the very fabric of our democratic institutions. "We cannot allow a handful of unelected tech billionaires to play roulette with humanity's future," stated the coalition's lead ethicist. By prioritizing human welfare over blind technological acceleration, the Act serves as a vital moral firewall, ensuring that the development of artificial general intelligence benefits society as a whole rather than just enriching the elite few."""
+ARTICLE_B = """Tech industry leaders and economists are sounding the alarm over the newly proposed Artificial Intelligence Safeguard Act, warning that the draconian legislation will severely cripple the nation’s economic engine. Critics argue that the bill is a masterclass in bureaucratic overreach, drowning agile tech startups in layers of punitive red tape and effectively stifling the very innovation that drives modern prosperity. By mandating arbitrary algorithmic audits and imposing heavy-handed restrictions on model training, the government is poised to surrender our global competitive edge to foreign adversaries who are not bound by such paralyzing regulations. "This isn't about safety; it's an innovation tax that penalizes success," argued a prominent venture capitalist. Analysts project that this short-sighted policy will force thousands of AI researchers to relocate overseas, draining billions of dollars in investment capital from the domestic market. Ultimately, framing technological progress as an inherent danger will only succeed in legislating the industry into obsolescence, destroying millions of future private-sector jobs in the process."""
+URL_A = "https://www.foxnews.com/live-news/trump-iran-israel-war-updates-march-30"
+URL_B = "https://edition.cnn.com/2026/03/30/world/live-news/iran-war-us-israel-trump"
 
-# Initialize the AI model
+# Initialize the Hugging Face Client
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-if GROQ_API_KEY:
-    client = Groq(api_key=GROQ_API_KEY)
-
-
-@st.cache_data(ttl=3600, show_spinner=False)
-def fetch_topic_news(query: str, limit: int = 8) -> list:
-    """Fetches news articles for a topic using Google News RSS."""
-    encoded_query = urllib.parse.quote(query)
-    rss_url = f"https://news.google.com/rss/search?q={encoded_query}&hl=en-US&gl=US&ceid=US:en"
-    
-    try:
-        response = requests.get(rss_url, timeout=10)
-        soup = BeautifulSoup(response.content, features="xml")
-        items = soup.findAll('item')[:limit]
-        
-        articles = []
-        for item in items:
-            articles.append({
-                "publisher": item.source.text if item.source else "Unknown Outlet",
-                "title": item.title.text,
-                "url": item.link.text
-            })
-        return articles
-    except Exception as e:
-        return []
+client = Groq(api_key=GROQ_API_KEY)
 
 def _truncate_to_words(text: str, limit: int) -> str:
     """Truncates text by word count."""
@@ -82,9 +62,11 @@ def analyze_article(text: str) -> dict:
     Text to analyze:
     "{safe_text}"
     """
+    
+    messages = [{"role": "user", "content": prompt}]
     response = client.chat.completions.create(
         model="llama-3.3-70b-versatile",
-        messages=[{"role": "user", "content": prompt}],
+        messages=messages,
         max_tokens=300,
         temperature=0.1,
         response_format={"type": "json_object"}
@@ -94,26 +76,96 @@ def analyze_article(text: str) -> dict:
     subjectivity_score = TextBlob(safe_text).sentiment.subjectivity
     raw_reading_ease = textstat.flesch_reading_ease(safe_text)
     
-    tones = llm_data.get("tone_scores", {})
-    standard_tones = {
-        "anger": tones.get("anger", 0.0),
-        "fear": tones.get("fear", 0.0),
-        "joy": tones.get("joy", 0.0),
-        "sadness": tones.get("sadness", 0.0),
-        "surprise": tones.get("surprise", 0.0),
-        "trust": tones.get("trust", 0.0),
-    }
-
     return {
         "sentiment_score": llm_data.get("sentiment_score", 0.0),
         "primary_tone": llm_data.get("primary_tone", "neutral"),
         "primary_theme": llm_data.get("primary_theme", "unclear"),
-        "tone_scores": standard_tones, 
+        "tone_scores": llm_data.get("tone_scores", {"anger": 0, "fear": 0, "joy": 0, "sadness": 0, "surprise": 0, "trust": 0}),
         "framing_words": llm_data.get("framing_words", []),
         "subjectivity_score": subjectivity_score,
         "reading_ease": max(0.0, min(100.0, raw_reading_ease)),
     }
 
+
+def _create_sentiment_gauge(score: float, title: str) -> go.Figure:
+    """Generates a Plotly gauge chart for sentiment visualization."""
+    fig = go.Figure(
+        go.Indicator(
+            mode="gauge+number",
+            value=score,
+            domain={"x": [0, 1], "y": [0, 1]},
+            title={"text": title, "font": {"size": 16}},
+            gauge={
+                "axis": {"range": [-1, 1], "tickwidth": 1, "tickcolor": "darkgrey"},
+                "bar": {"color": "#475569", "thickness": 0.2}, 
+                "bgcolor": "white",
+                "borderwidth": 0,
+                "steps": [
+                    {"range": [-1, -0.1], "color": "#fee2e2"}, 
+                    {"range": [-0.1, 0.1], "color": "#f1f5f9"}, 
+                    {"range": [0.1, 1], "color": "#dcfce3"},   
+                ],
+            },
+        )
+    )
+    fig.update_layout(height=280, margin=dict(l=20, r=20, t=60, b=20))
+    return fig
+
+
+def _create_comparison_radar_chart(results_a: dict, results_b: dict) -> go.Figure:
+    """Generates an overlapping radar chart to compare emotions."""
+    categories = sorted(list(set(list(results_a["tone_scores"].keys()) + list(results_b["tone_scores"].keys()))))
+    
+    val_a = [results_a["tone_scores"].get(c, 0) for c in categories]
+    val_b = [results_b["tone_scores"].get(c, 0) for c in categories]
+    
+    categories.append(categories[0])
+    val_a.append(val_a[0])
+    val_b.append(val_b[0])
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatterpolar(
+          r=val_a, theta=categories, fill='toself', name='Source A', 
+          line=dict(color='#4f46e5', shape='spline', width=2),
+          fillcolor='rgba(79, 70, 229, 0.2)' 
+    ))
+    fig.add_trace(go.Scatterpolar(
+          r=val_b, theta=categories, fill='toself', name='Source B', 
+          line=dict(color='#10b981', shape='spline', width=2),
+          fillcolor='rgba(16, 185, 129, 0.2)' 
+    ))
+    fig.update_layout(
+      polar=dict(
+          radialaxis=dict(visible=True, showticklabels=False, showline=False, gridcolor='rgba(0,0,0,0.1)'),
+          angularaxis=dict(gridcolor='rgba(0,0,0,0.1)', linecolor='rgba(0,0,0,0.1)')
+      ),
+      showlegend=True,
+      legend=dict(orientation="h", yanchor="bottom", y=-0.2, xanchor="center", x=0.5), 
+      title={"text": "Relative Emotion Profile", "font": {"size": 18, "family": "sans-serif"}},
+      height=400,
+      margin=dict(l=40, r=40, t=60, b=40),
+      paper_bgcolor='rgba(0,0,0,0)', # Transparent
+      plot_bgcolor='rgba(0,0,0,0)'
+    )
+    return fig
+
+
+def _highlight_framing_words(text: str, target_words: list) -> str:
+    """Highlights LLM-identified framing words in the synced text snippet."""
+    display_text = _truncate_to_words(text, MAX_WORDS)
+    if not display_text:
+        return ""
+    
+    highlighted_text = display_text + ("..." if len(text.split()) > MAX_WORDS else "")
+    
+    for word in target_words:
+        if len(word) > 2: 
+            pattern = r'\b(' + re.escape(word) + r')\b'
+            replacement = r"<span style='background-color: #fef08a; color: #854d0e; font-weight: 600; padding: 0.1rem 0.2rem; border-radius: 4px;'>\1</span>"
+            highlighted_text = re.sub(pattern, replacement, highlighted_text, flags=re.IGNORECASE)
+
+    return highlighted_text
+
 @st.cache_data(ttl=3600, show_spinner=False)
 def fetch_article_text(url: str) -> str:
     """Scrapes article text."""
@@ -145,103 +197,181 @@ def fetch_article_text(url: str) -> str:
 
     return "Error: Could not extract text. The site may be protected by hard paywalls."
 
-def _create_macro_scatter_plot(results: list) -> go.Figure:
-    """Generates a scatter plot of multiple media outlets."""
-    fig = go.Figure()
-    
-    color_map = {
-        "economic consequences": "#3b82f6", 
-        "moral and ethical fairness": "#10b981", 
-        "legal and bureaucratic": "#f59e0b", 
-        "public safety and health": "#ef4444",
-        "unclear": "#64748b"
-    }
 
-    for res in results:
-        theme = str(res['data']['primary_theme']).lower()
-        color = color_map.get(theme, "#64748b")
-        words = ", ".join(res['data']['framing_words'])
-        
-        hover_text = f"<b>{res['publisher']}</b><br>Theme: {theme.title()}<br>Keywords: {words}"
-        
-        fig.add_trace(go.Scatter(
-            x=[res['data']['sentiment_score']],
-            y=[res['data']['subjectivity_score']],
-            mode='markers+text',
-            text=[res['publisher']],
-            textposition="top center",
-            marker=dict(size=14, color=color, line=dict(width=1, color='DarkSlateGrey')),
-            name=theme.title(),
-            hoverinfo="text",
-            hovertext=[hover_text],
-            showlegend=False 
-        ))
-
-    fig.update_layout(
-        title="Global Media Polarization Map",
-        xaxis_title="Sentiment (Negative to Positive)",
-        yaxis_title="Subjectivity (Objective to Opinionated)",
-        xaxis=dict(range=[-1.1, 1.1], zeroline=True, zerolinewidth=2, zerolinecolor='rgba(0,0,0,0.2)'),
-        yaxis=dict(range=[-0.1, 1.1], zeroline=True, zerolinewidth=2, zerolinecolor='rgba(0,0,0,0.2)'),
-        height=600,
-        plot_bgcolor='#f8fafc'
+def check_contradiction(text_a: str, text_b: str) -> dict:
+    """Uses the LLM to evaluate the stance between arguments."""
+    safe_a = _truncate_to_words(text_a, MAX_WORDS)
+    safe_b = _truncate_to_words(text_b, MAX_WORDS)
+    
+    prompt = f"""
+    You are a fact-checking analyst. Compare these two news excerpts.
+    Return ONLY a valid JSON object with the exact keys below. Do not include markdown formatting.
+    
+    Keys to return:
+    "relationship": Choose ONE from: ["CONTRADICTION", "ENTAILMENT", "NEUTRAL"]. (Contradiction = disputing facts, Entailment = agreeing on premise).
+    "confidence": A float between 0.0 and 1.0 representing how confident you are.
+    
+    Text 1: "{safe_a}"
+    Text 2: "{safe_b}"
+    """
+    messages = [{"role": "user", "content": prompt}]
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=messages,
+        max_tokens=100,
+        temperature=0.1,
+        response_format={"type": "json_object"}
     )
-    return fig
-
     
+    result = json.loads(response.choices[0].message.content)
+    return {"relationship": result.get("relationship", "NEUTRAL"), "confidence": result.get("confidence", 0.0)}
+    
+
+# USER INTERFACE
+st.set_page_config(page_title="FrameVis | Media Framing", layout="wide")
+
 if not GROQ_API_KEY:
     st.warning("Groq API Token Missing.")
     st.stop()
 
+st.markdown("""
+<style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    
+    .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    
+    [data-testid="stMetric"] {
+        background-color: #f8fafc;
+        border: 1px solid #e2e8f0;
+        border-radius: 8px;
+        padding: 15px;
+        box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+    }
+
+    [data-testid="stMetricValue"] > div {
+        white-space: normal !important;
+        word-wrap: break-word !important;
+        line-height: 1.2 !important;
+        font-size: 1.6rem !important; 
+    }
+</style>
+""", unsafe_allow_html=True)
+
 # STATE MANAGEMENT
-if "batch_results" not in st.session_state:
-    st.session_state.batch_results = []
+if "results_a" not in st.session_state:
+    st.session_state.results_a = None
+if "results_b" not in st.session_state:
+    st.session_state.results_b = None
+if "nli_result" not in st.session_state:
+    st.session_state.nli_result = None
 
-search_topic = st.text_input("Enter a Global Event or Topic (e.g., 'Artificial Intelligence Act', 'Middle East Conflict')", placeholder="Search topic...")
+st.title("FrameVis")
+st.markdown("##### Media bias and framing effects across global news sources.")
+st.divider()
 
-if st.button("Generate Media Landscape", type="primary", use_container_width=True):
-    if not search_topic:
-        st.warning("Please enter a topic.")
+input_method = st.radio("Input Method", ["Paste Text", "Paste URL"], horizontal=True, index=0)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    if input_method == "Paste Text":
+        user_article_a = st.text_area("Data Source A", value=ARTICLE_A.strip(), height=220)
     else:
-        with st.spinner(f"Fetching global articles for '{search_topic}'..."):
-            articles = fetch_topic_news(search_topic, limit=10) 
-            
-            if not articles:
-                st.error("Could not find recent articles for this topic.")
-            else:
-                st.info(f"Found {len(articles)} articles. Analyzing framing semantics.")
-                processed_results = []
-                
-                with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
-                    future_to_article = {}
-                    for art in articles:
-                        text = fetch_article_text(art["url"])
-                        if not text.startswith("Error"):
-                            future = executor.submit(analyze_article, text)
-                            future_to_article[future] = art
+        url_a = st.text_input("Source A URL", value=URL_A)
+        user_article_a = fetch_article_text(url_a) if url_a else ""
+
+with col2:
+    if input_method == "Paste Text":
+        user_article_b = st.text_area("Data Source B", value=ARTICLE_B.strip(), height=220)
+    else:
+        url_b = st.text_input("Source B URL", value=URL_B)
+        user_article_b = fetch_article_text(url_b) if url_b else ""
+
+st.write("")
+
+# Execution button
+if st.button("Analyze and Compare Sources", use_container_width=True, type="primary"):
+    
+    text_a_clean = user_article_a.strip() if user_article_a else ""
+    text_b_clean = user_article_b.strip() if user_article_b else ""
+
+    if not text_a_clean or not text_b_clean:
+        st.warning("Please provide text or a valid URL for both Source A and Source B before analyzing.")
+    
+    elif text_a_clean.startswith("Error:") or text_b_clean.startswith("Error:"):
+        st.error("One of the URLs could not be scraped. Please copy and paste the text directly.")
+    
+    else:
+        with st.spinner("Analyzing framing semantics for both sources."):
+            try:
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future_a = executor.submit(analyze_article, text_a_clean)
+                    future_b = executor.submit(analyze_article, text_b_clean)
+                    future_nli = executor.submit(check_contradiction, text_a_clean, text_b_clean)
                     
-                    for future in concurrent.futures.as_completed(future_to_article):
-                        art_meta = future_to_article[future]
-                        try:
-                            analysis_data = future.result()
-                            processed_results.append({
-                                "publisher": art_meta["publisher"],
-                                "title": art_meta["title"],
-                                "data": analysis_data
-                            })
-                        except Exception as e:
-                            pass
-                
-                st.session_state.batch_results = processed_results
-
-# Macro Analysis
-if st.session_state.batch_results:
+                    st.session_state.results_a = future_a.result()
+                    st.session_state.results_b = future_b.result()
+                    st.session_state.nli_result = future_nli.result()
+            except Exception as e:
+                st.error(f"API or Processing Error: {str(e)}")
+                st.session_state.results_a = None
+                st.session_state.results_b = None
+                st.session_state.nli_result = None
+
+# Analysis Display
+if st.session_state.results_a and st.session_state.results_b:
     st.divider()
-    st.plotly_chart(_create_macro_scatter_plot(st.session_state.batch_results), use_container_width=True)
-    
-    st.markdown("### Source Breakdown")
-    for res in st.session_state.batch_results:
-        with st.expander(f"{res['publisher']} - {res['data']['primary_theme'].title()}"):
-            st.write(f"**Headline:** {res['title']}")
-            st.write(f"**Framing Words:** {', '.join(res['data']['framing_words'])}")
-            st.write(f"**Sentiment:** {res['data']['sentiment_score']:.2f} | **Subjectivity:** {res['data']['subjectivity_score']:.2f}")
+    st.markdown("### Framing Analytics & Comparison")
+    
+    # Display Contradictions
+    nli_result = st.session_state.nli_result
+    if nli_result:
+        if nli_result["relationship"].upper() == "CONTRADICTION":
+            st.error(f"**NARRATIVE CONTRADICTION** (Confidence: {nli_result['confidence']:.2f}) - These sources are disputing each other's facts.")
+        elif nli_result["relationship"].upper() == "ENTAILMENT":
+            st.success(f"**NARRATIVE ALIGNMENT** (Confidence: {nli_result['confidence']:.2f}) - These sources agree on the core premise.")
+        else:
+            st.info(f"**NEUTRAL RELATIONSHIP** - These sources are discussing the topic without direct contradiction or alignment.")
+            
+    st.plotly_chart(_create_comparison_radar_chart(st.session_state.results_a, st.session_state.results_b), use_container_width=True)
+
+    res_col1, res_col2 = st.columns(2)
+
+    # Render Column A
+    with res_col1:
+        r_a = st.session_state.results_a
+        st.markdown("#### Source A Breakdown")
+        m1, m2 = st.columns(2)
+        m3, m4 = st.columns(2)
+        m1.metric("Subjectivity", f"{r_a['subjectivity_score']:.2f}", help="0 is objective, 1 is highly opinionated.")
+        m2.metric("Primary Emotion", str(r_a['primary_tone']).title())
+        m3.metric("Framing Lens", str(r_a['primary_theme']).title())
+        m4.metric("Reading Ease", f"{r_a['reading_ease']:.1f}", help="0-30 is college graduate level, 60-70 is 8th grade.")
+
+        st.plotly_chart(_create_sentiment_gauge(r_a["sentiment_score"], "Sentiment Bias"), use_container_width=True, key="gauge_a")
+
+        st.markdown("**Key Framing Language:**")
+        annotated_text = _highlight_framing_words(user_article_a, r_a['framing_words'])
+        st.markdown(f"<div style='background-color: #f8fafc; padding: 1rem; border-radius: 8px; border: 1px solid #e2e8f0;'>{annotated_text}</div>", unsafe_allow_html=True)
+
+    # Render Column B
+    with res_col2:
+        r_b = st.session_state.results_b
+        st.markdown("#### Source B Breakdown")
+        m1, m2 = st.columns(2)
+        m3, m4 = st.columns(2)
+        m1.metric("Subjectivity", f"{r_b['subjectivity_score']:.2f}", help="0 is objective, 1 is highly opinionated.")
+        m2.metric("Primary Emotion", str(r_b['primary_tone']).title())
+        m3.metric("Framing Lens", str(r_b['primary_theme']).title())
+        m4.metric("Reading Ease", f"{r_b['reading_ease']:.1f}", help="0-30 is college graduate level, 60-70 is 8th grade.")
+
+        st.plotly_chart(_create_sentiment_gauge(r_b["sentiment_score"], "Sentiment Bias"), use_container_width=True, key="gauge_b")
+
+        st.markdown("**Key Framing Language:**")
+        annotated_text = _highlight_framing_words(user_article_b, r_b['framing_words'])
+        st.markdown(f"<div style='background-color: #f8fafc; padding: 1rem; border-radius: 8px; border: 1px solid #e2e8f0;'>{annotated_text}</div>", unsafe_allow_html=True)