app.py

import gradio as gr
import requests
from bs4 import BeautifulSoup
from transformers import pipeline
import re
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class FakeNewsDetector:
    def __init__(self):
        logger.info("Loading RoBERTa Fake News Detection model...")
        
        try:
            # Using the most popular and proven model
            MODEL = "jy46604790/Fake-News-Bert-Detect"
            
            # Simple pipeline approach - handles everything automatically
            self.classifier = pipeline(
                "text-classification",
                model=MODEL,
                tokenizer=MODEL,
                device=-1,  # CPU mode for free tier
                max_length=512,  # Explicitly set max length
                truncation=True  # Enable truncation
            )
            
            logger.info("✅ Model loaded successfully!")
            
        except Exception as e:
            logger.error(f"Error loading model: {e}")
            raise
        
        # Credible sources
        self.credible_sources = [
            'reuters.com', 'apnews.com', 'bbc.com', 'nytimes.com',
            'theguardian.com', 'washingtonpost.com', 'npr.org',
            'wsj.com', 'ft.com', 'bloomberg.com', 'abcnews.go.com',
            'cbsnews.com', 'nbcnews.com', 'cnn.com', 'axios.com'
        ]
        
        # Fake news indicators
        self.fake_indicators = [
            "exclusive reveal", "shocking truth", "they don't want you to know",
            "mainstream media won't report", "breaking secret", "you won't believe",
            "wake up sheeple", "open your eyes"
        ]

    def extract_content(self, url: str):
        """Extract content from URL"""
        try:
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
            }
            
            if not url.startswith(('http://', 'https://')):
                url = 'https://' + url
            
            response = requests.get(url, headers=headers, timeout=15)
            response.raise_for_status()
            
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # Remove unwanted elements
            for element in soup(["script", "style", "nav", "footer", "header", "aside"]):
                element.decompose()
            
            # Extract title
            title = soup.find('title')
            title_text = title.get_text().strip() if title else "No title found"
            
            # Try multiple content selectors
            content_text = ""
            content_selectors = [
                'article', '.article-content', '.post-content',
                '.story-content', '.entry-content', 'main',
                '[role="main"]', '.news-content', '.story-body'
            ]
            
            for selector in content_selectors:
                elements = soup.select(selector)
                if elements:
                    content_parts = []
                    for elem in elements:
                        text = elem.get_text().strip()
                        if len(text) > 100:
                            content_parts.append(text)
                    if content_parts:
                        content_text = ' '.join(content_parts)
                        break
            
            # Fallback to body
            if not content_text or len(content_text) < 200:
                body = soup.find('body')
                if body:
                    content_text = body.get_text()
            
            # Clean text
            content_text = self.clean_text(content_text)
            
            return {
                'success': True,
                'title': title_text,
                'content': content_text,
                'url': url
            }
            
        except Exception as e:
            logger.error(f"Content extraction error: {e}")
            return {'success': False, 'error': str(e)}

    def clean_text(self, text: str):
        """Clean and normalize text"""
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'[^\w\s.,!?;:()-]', '', text)
        return text.strip()

    def truncate_text(self, text: str, max_words: int = 350):
        """Truncate text to maximum words for the model"""
        words = text.split()
        if len(words) > max_words:
            truncated = ' '.join(words[:max_words])
            logger.info(f"Text truncated from {len(words)} to {max_words} words")
            return truncated
        return text

    def analyze_content(self, text: str):
        """Analyze text for fake news indicators"""
        text_lower = text.lower()
        
        fake_indicator_count = sum(1 for indicator in self.fake_indicators if indicator in text_lower)
        exclamation_count = text.count('!')
        capital_words = len(re.findall(r'\b[A-Z]{3,}\b', text))
        
        return {
            'fake_indicator_count': fake_indicator_count,
            'exclamation_count': exclamation_count,
            'capital_words': capital_words
        }

    def check_source_credibility(self, url: str):
        """Check source credibility"""
        url_lower = url.lower()
        
        for credible_source in self.credible_sources:
            if credible_source in url_lower:
                return 0.9
        
        unreliable = ['.blogspot.', '.wordpress.', '.tumblr.']
        for domain in unreliable:
            if domain in url_lower:
                return 0.1
                
        return 0.5

    def detect_fake_news(self, url: str):
        """Main detection function"""
        logger.info(f"Analyzing: {url}")
        
        # Extract content
        content_data = self.extract_content(url)
        if not content_data['success']:
            return {
                'status': '❌ Extraction Failed',
                'confidence': 0.0,
                'message': f"Could not extract content: {content_data.get('error', 'Unknown error')}",
                'title': 'Error'
            }
        
        title = content_data['title']
        content = content_data['content']
        
        if len(content.strip()) < 100:
            return {
                'status': '⚠️ Insufficient Content',
                'confidence': 0.0,
                'message': 'Not enough content to analyze. May be behind paywall.',
                'title': title
            }
        
        # Prepare text for model (title + truncated content)
        full_text = f"{title}. {content}"
        
        # Truncate text to safe length for the model
        truncated_text = self.truncate_text(full_text, max_words=350)
        logger.info(f"Text length: {len(truncated_text)} characters")
        
        # Use RoBERTa model with error handling
        try:
            result = self.classifier(truncated_text)[0]
            
            label = result['label']
            score = result['score']
            
            # Debug: Log the raw output
            logger.info(f"Raw model output: {result}")
            
            # Parse label correctly - check both possible label formats
            if label in ['LABEL_1', 'FAKE', 'Fake']:
                is_fake = True
                model_confidence = score
            elif label in ['LABEL_0', 'REAL', 'Real']:
                is_fake = False
                model_confidence = score
            else:
                # If label format is unexpected, use score threshold
                is_fake = score > 0.5
                model_confidence = score if is_fake else (1 - score)
            
            logger.info(f"Interpreted: is_fake={is_fake}, confidence={model_confidence:.3f}")
            
        except Exception as e:
            logger.error(f"Model error: {e}")
            # Fallback to content analysis only
            return self.fallback_analysis(title, content, url, str(e))
        
        # Additional analysis
        source_credibility = self.check_source_credibility(url)
        content_analysis = self.analyze_content(full_text)
        
        # Calculate combined score based on model prediction
        if is_fake:
            # For fake news: model confidence + source suspicion + content indicators
            combined_score = (
                model_confidence * 0.7 +
                (1 - source_credibility) * 0.2 +
                min(content_analysis['fake_indicator_count'] * 0.1, 0.1)
            )
        else:
            # For real news: model confidence + source credibility
            combined_score = (
                model_confidence * 0.8 +
                source_credibility * 0.2
            )
        
        # Determine status based on clear thresholds
        if is_fake:
            if combined_score > 0.8:
                status = "🚨 Highly Likely Fake News"
            elif combined_score > 0.6:
                status = "⚠️ Likely Fake News"
            elif combined_score > 0.4:
                status = "🤔 Possibly Fake News"
            else:
                status = "📰 Uncertain (Leaning Fake)"
        else:
            if combined_score > 0.8:
                status = "✅ Highly Likely Real News"
            elif combined_score > 0.6:
                status = "📰 Likely Real News"
            elif combined_score > 0.4:
                status = "🤔 Possibly Real News"
            else:
                status = "❓ Uncertain (Leaning Real)"
        
        # Detailed message
        message = f"""
**📊 Analysis Results:**

**RoBERTa Model Prediction:**
- Classification: **{'FAKE NEWS' if is_fake else 'REAL NEWS'}**
- Model Confidence: **{model_confidence * 100:.1f}%**
- Raw Output: `{label}` (score: {score:.3f})

**Source Analysis:**
- Source Credibility: {source_credibility:.2f}/1.0
- Domain: {url.split('/')[2] if len(url.split('/')) > 2 else 'Unknown'}

**Content Indicators:**
- Fake News Keywords: {content_analysis['fake_indicator_count']}
- Exclamation Marks: {content_analysis['exclamation_count']}
- ALL-CAPS Words: {content_analysis['capital_words']}

**Final Score: {combined_score * 100:.1f}%**

**Content Preview:**
{content[:300]}...

---
**Note:** This is an AI prediction. Always verify from multiple sources.
        """.strip()
        
        return {
            'status': status,
            'confidence': combined_score,
            'message': message,
            'title': title
        }

    def fallback_analysis(self, title: str, content: str, url: str, error: str):
        """Fallback analysis when model fails"""
        source_credibility = self.check_source_credibility(url)
        content_analysis = self.analyze_content(f"{title}. {content}")
        
        # Simple heuristic based on source and content
        fake_score = (
            (1 - source_credibility) * 0.6 +
            min(content_analysis['fake_indicator_count'] * 0.2, 0.4)
        )
        
        if fake_score > 0.7:
            status = "⚠️ Suspicious (Fallback Analysis)"
        elif fake_score > 0.4:
            status = "🤔 Uncertain (Fallback Analysis)"
        else:
            status = "📰 Probably Real (Fallback Analysis)"
        
        message = f"""
**📊 Fallback Analysis (Model Error):**

**Model Error:** {error}

**Source Analysis:**
- Source Credibility: {source_credibility:.2f}/1.0

**Content Indicators:**
- Fake News Keywords: {content_analysis['fake_indicator_count']}
- Exclamation Marks: {content_analysis['exclamation_count']}
- ALL-CAPS Words: {content_analysis['capital_words']}

**Fallback Score: {fake_score * 100:.1f}%**

**Preview:**
{content[:300]}...

---
*Using fallback analysis due to model error*
        """.strip()
        
        return {
            'status': status,
            'confidence': fake_score,
            'message': message,
            'title': title
        }

# Initialize detector
logger.info("Initializing Fake News Detector...")
detector = FakeNewsDetector()
logger.info("Ready!")

def analyze_url(url):
    """Gradio interface function"""
    if not url.strip():
        return "⚠️ Please enter a URL", "0%", "No URL provided", "No title"
    
    try:
        result = detector.detect_fake_news(url)
        confidence_percent = f"{result['confidence'] * 100:.1f}%"
        
        return (
            result['status'],
            confidence_percent,
            result['message'],
            result['title']
        )
        
    except Exception as e:
        logger.error(f"Error: {e}")
        return "❌ Error", "0%", f"Error: {str(e)}", "Error"

# Gradio Interface
with gr.Blocks(
    theme=gr.themes.Soft(),
    title="Fake News Detector"
) as demo:
    
    gr.Markdown("""
    # 🕵️ Fake News Detector
    **AI-Powered News Verification using RoBERTa**
    
    *Analyzes news articles using a transformer model trained on 40,000+ articles*
    """)
    
    with gr.Row():
        with gr.Column(scale=2):
            url_input = gr.Textbox(
                label="📰 Enter News Article URL",
                placeholder="https://example.com/news-article",
                lines=1
            )
            analyze_btn = gr.Button(
                "🔍 Analyze Article",
                variant="primary",
                size="lg"
            )
        
        with gr.Column(scale=1):
            with gr.Group():
                result_status = gr.Textbox(
                    label="🎯 Result",
                    interactive=False
                )
                confidence_score = gr.Textbox(
                    label="📈 Confidence",
                    interactive=False
                )
                article_title = gr.Textbox(
                    label="📝 Article Title",
                    interactive=False
                )
    
    details_output = gr.Markdown(label="📊 Detailed Analysis")
    
    gr.Examples(
        label="💡 Try these examples:",
        examples=[
            ["https://www.bbc.com/news"],
            ["https://www.reuters.com/"],
            ["https://apnews.com/"]
        ],
        inputs=url_input
    )
    
    gr.Markdown("""
    ---
    
    **How it works:**
    
    1. **Extracts** article text from URL
    2. **Truncates** to model-safe length (350 words)
    3. **Analyzes** using RoBERTa transformer
    4. **Checks** source credibility and content patterns
    5. **Provides** confidence score
    
    **Model:** `jy46604790/Fake-News-Bert-Detect` (RoBERTa-based)
    
    **⚠️ Disclaimer:** Educational tool only. Always verify information through multiple credible sources.
    """)
    
    analyze_btn.click(
        fn=analyze_url,
        inputs=url_input,
        outputs=[result_status, confidence_score, details_output, article_title]
    )

if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860
    )