Update app.py

app.py

@@ -1,16 +1,53 @@
 import streamlit as st
 import pandas as pd
 import requests
-import textblob
+from textblob import TextBlob
 from transformers import pipeline
+import nltk
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
 from nltk.tokenize import sent_tokenize
 import numpy as np
+import json
+from urllib.parse import quote
+
+class FactChecker:
+    def __init__(self):
+        self.google_fact_check_api = "https://factchecktools.googleapis.com/v1alpha1/claims:search"
+        
+    def check_claim(self, claim_text):
+        """Use free fact checking APIs to verify claims"""
+        # Using WikiMedia API for basic fact verification
+        wiki_api = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={quote(claim_text)}&format=json"
+        try:
+            response = requests.get(wiki_api)
+            results = response.json()
+            return {
+                'found_matches': len(results.get('query', {}).get('search', [])) > 0,
+                'confidence': min(len(results.get('query', {}).get('search', [])) / 5.0, 1.0),
+                'sources': ['Wikipedia']
+            }
+        except:
+            return {'found_matches': False, 'confidence': 0.0, 'sources': []}
 
 class AIOutputAnalyzer:
     def __init__(self):
-        self.sentiment_analyzer = pipeline("sentiment-analysis")
-        self.qa_pipeline = pipeline("question-answering")
+        try:
+            self.sentiment_analyzer = pipeline("sentiment-analysis")
+        except:
+            st.error("Error loading sentiment analyzer. Using fallback method.")
+            self.sentiment_analyzer = None
+        self.fact_checker = FactChecker()
         
+    def analyze_sentiment_fallback(self, text):
+        """Fallback method using TextBlob for sentiment analysis"""
+        blob = TextBlob(text)
+        polarity = blob.sentiment.polarity
+        return [{'label': 'POSITIVE' if polarity > 0 else 'NEGATIVE', 
+                'score': abs(polarity)}]
+    
     def check_bias(self, text):
         """Analyze text for potential bias using sentiment and keyword analysis"""
         results = {
@@ -19,117 +56,166 @@ class AIOutputAnalyzer:
             'balanced_perspective': 0
         }
         
-        # Analyze sentiment of each sentence
-        sentences = sent_tokenize(text)
-        sentiments = [self.sentiment_analyzer(sent)[0] for sent in sentences]
-        
-        # Check for emotional language
-        strong_sentiments = sum(1 for s in sentiments if abs(float(s['score'])) > 0.8)
-        results['emotional_language'] = strong_sentiments / len(sentences)
-        
-        # Analyze subjectivity using TextBlob
-        blob = textblob.TextBlob(text)
-        results['subjective_statements'] = blob.subjectivity
-        
-        # Calculate overall bias score
-        results['balanced_perspective'] = 1 - ((results['emotional_language'] + 
-                                             results['subjective_statements']) / 2)
-        
+        try:
+            # Analyze sentiment of each sentence
+            sentences = sent_tokenize(text)
+            if self.sentiment_analyzer:
+                sentiments = [self.sentiment_analyzer(sent)[0] for sent in sentences]
+            else:
+                sentiments = [self.analyze_sentiment_fallback(sent)[0] for sent in sentences]
+            
+            # Check for emotional language
+            strong_sentiments = sum(1 for s in sentiments if abs(float(s['score'])) > 0.8)
+            results['emotional_language'] = strong_sentiments / len(sentences)
+            
+            # Analyze subjectivity
+            blob = TextBlob(text)
+            results['subjective_statements'] = blob.sentiment.subjectivity
+            
+            # Calculate overall bias score
+            results['balanced_perspective'] = 1 - ((results['emotional_language'] + 
+                                                 results['subjective_statements']) / 2)
+        except Exception as e:
+            st.error(f"Error in bias analysis: {str(e)}")
+            results = {'emotional_language': 0, 'subjective_statements': 0, 
+                      'balanced_perspective': 0.5}
+            
         return results
 
     def verify_factual_claims(self, text):
-        """Extract and attempt to verify factual claims in the text"""
-        sentences = sent_tokenize(text)
-        claims = []
-        
-        for sentence in sentences:
-            if any(keyword in sentence.lower() for keyword in 
-                  ['is', 'are', 'was', 'were', 'will', 'has', 'have']):
-                claims.append({
-                    'claim': sentence,
-                    'confidence': self._assess_claim_confidence(sentence),
-                    'needs_verification': True
-                })
-        
-        return claims
-    
-    def _assess_claim_confidence(self, claim):
-        """Assess confidence level of a claim based on language patterns"""
-        confidence = 0.5  # Base confidence
-        
-        # Reduce confidence for uncertain language
-        uncertainty_markers = ['might', 'maybe', 'possibly', 'could', 'perhaps']
-        if any(marker in claim.lower() for marker in uncertainty_markers):
-            confidence -= 0.2
+        """Extract and verify factual claims in the text"""
+        try:
+            sentences = sent_tokenize(text)
+            claims = []
             
-        # Increase confidence for citations or specific numbers
-        if any(char.isdigit() for char in claim) or '[' in claim:
-            confidence += 0.2
+            for sentence in sentences:
+                if any(keyword in sentence.lower() for keyword in 
+                      ['is', 'are', 'was', 'were', 'will', 'has', 'have']):
+                    # Check facts using external APIs
+                    fact_check_result = self.fact_checker.check_claim(sentence)
+                    
+                    claims.append({
+                        'claim': sentence,
+                        'confidence': fact_check_result['confidence'],
+                        'needs_verification': not fact_check_result['found_matches'],
+                        'sources': fact_check_result['sources']
+                    })
             
-        return min(1.0, max(0.0, confidence))
+            return claims
+        except Exception as e:
+            st.error(f"Error in claim verification: {str(e)}")
+            return []
+
+def create_report(text, bias_results, claims):
+    """Generate a detailed analysis report"""
+    report = f"""
+# AI Output Analysis Report
+
+## Content Overview
+Length: {len(text)} characters
+Sentences analyzed: {len(sent_tokenize(text))}
+
+## Bias Analysis
+- Emotional Language Score: {bias_results['emotional_language']:.2%}
+- Subjective Content Score: {bias_results['subjective_statements']:.2%}
+- Balance Score: {bias_results['balanced_perspective']:.2%}
+
+## Factual Claims Analysis
+Total claims analyzed: {len(claims)}
+
+### Detailed Claims Breakdown:
+"""
+    
+    for i, claim in enumerate(claims, 1):
+        report += f"""
+Claim {i}:
+- Statement: "{claim['claim']}"
+- Confidence: {claim['confidence']:.2%}
+- Status: {"Verified" if not claim['needs_verification'] else "Needs Verification"}
+- Sources: {', '.join(claim['sources'])}
+"""
+    
+    return report
 
 def main():
+    st.set_page_config(page_title="AI Output Accountability Checker", 
+                      layout="wide")
+    
     st.title("AI Output Accountability Checker")
     st.markdown("""
-    ### Analyze AI-generated content for:
-    - Bias and subjectivity
-    - Factual claims verification
-    - Source credibility
+    ### Analyze AI-generated content for bias, facts, and credibility
+    Upload or paste AI-generated content to get a comprehensive analysis.
     """)
     
+    # Sidebar for language selection
+    languages = ["English", "Spanish", "French", "German"]
+    selected_language = st.sidebar.selectbox("Select Language", languages)
+    
     # Input section
-    ai_output = st.text_area("Paste AI-generated content here:", height=200)
+    input_method = st.radio("Choose input method:", 
+                           ["Text Input", "File Upload"])
+    
+    if input_method == "File Upload":
+        uploaded_file = st.file_uploader("Upload a text file", type=['txt'])
+        if uploaded_file:
+            ai_output = uploaded_file.read().decode()
+        else:
+            ai_output = ""
+    else:
+        ai_output = st.text_area("Paste AI-generated content here:", 
+                                height=200)
     
     if st.button("Analyze"):
         if ai_output:
             analyzer = AIOutputAnalyzer()
             
-            # Progress bar
+            # Analysis with progress tracking
             progress_bar = st.progress(0)
+            status_text = st.empty()
             
             # Bias Analysis
-            st.subheader("Bias Analysis")
-            with st.spinner("Analyzing bias..."):
-                bias_results = analyzer.check_bias(ai_output)
-                progress_bar.progress(0.33)
-                
-                col1, col2, col3 = st.columns(3)
-                col1.metric("Emotional Language", 
-                          f"{bias_results['emotional_language']:.2%}")
-                col2.metric("Subjective Content", 
-                          f"{bias_results['subjective_statements']:.2%}")
-                col3.metric("Balance Score", 
-                          f"{bias_results['balanced_perspective']:.2%}")
+            status_text.text("Analyzing bias...")
+            bias_results = analyzer.check_bias(ai_output)
+            progress_bar.progress(0.33)
+            
+            # Claims Analysis
+            status_text.text("Verifying claims...")
+            claims = analyzer.verify_factual_claims(ai_output)
+            progress_bar.progress(0.66)
             
-            # Factual Claims
-            st.subheader("Factual Claims Analysis")
-            with st.spinner("Analyzing claims..."):
-                claims = analyzer.verify_factual_claims(ai_output)
-                progress_bar.progress(0.66)
+            # Generate Report
+            status_text.text("Generating report...")
+            report = create_report(ai_output, bias_results, claims)
+            progress_bar.progress(1.0)
+            status_text.text("Analysis complete!")
+            
+            # Display Results
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("Quick Analysis")
+                st.metric("Overall Reliability", 
+                         f"{(bias_results['balanced_perspective'] + np.mean([c['confidence'] for c in claims])) / 2:.2%}")
                 
+                # Interactive claims analysis
+                st.subheader("Claims Analysis")
                 for claim in claims:
                     with st.expander(f"Claim (Confidence: {claim['confidence']:.2%})"):
                         st.write(claim['claim'])
+                        st.write(f"Sources: {', '.join(claim['sources'])}")
                         if claim['needs_verification']:
-                            st.warning("⚠️ This claim requires verification")
-            
-            # Overall Assessment
-            st.subheader("Overall Assessment")
-            progress_bar.progress(1.0)
-            
-            overall_score = (bias_results['balanced_perspective'] + 
-                           np.mean([c['confidence'] for c in claims])) / 2
-            
-            st.markdown(f"""
-            ### Reliability Score: {overall_score:.2%}
-            
-            **Recommendations:**
-            - {'✅ Content appears relatively unbiased' if bias_results['balanced_perspective'] > 0.7 
-               else '⚠️ Content shows potential bias'}
-            - {'✅ Claims are well-supported' if np.mean([c['confidence'] for c in claims]) > 0.7 
-               else '⚠️ Some claims need verification'}
-            """)
+                            st.warning("⚠️ This claim needs additional verification")
             
+            with col2:
+                st.subheader("Detailed Report")
+                st.download_button(
+                    label="Download Report",
+                    data=report,
+                    file_name="ai_analysis_report.md",
+                    mime="text/markdown"
+                )
+                st.markdown(report)
+        
         else:
             st.warning("Please enter some text to analyze.")