Create initial project structure

.env.example

@@ -0,0 +1 @@
+NEWSAPI_KEY=your_newsapi_key_here

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,23 @@
+# Environment variables
+.env
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Virtual environment
+.venv/
+venv/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.13.5-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1 +1,183 @@
-# BootcampFinalProject
+---
+title: AI News Sentiment Analyzer
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: "1.28.0"
+app_file: src/streamlit_app.py
+pinned: false
+---
+
+# 🤖 AI News Sentiment Analyzer
+
+An interactive web application that fetches the latest AI-related news and analyzes the sentiment of headlines and articles. Built with Python, Streamlit, and powered by NewsAPI.
+
+## 🛠️ Installation
+
+### Prerequisites
+- Python 3.9+ 
+- NewsAPI key (get free at [newsapi.org](https://newsapi.org))
+
+### Setup Instructions
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/alexoh2bd/BootcampFinalProject
+   cd BootcampFinalProject
+   ```
+
+2. **Create virtual environment**
+   ```bash
+   # macOS/Linux
+   python3 -m venv .venv
+   source .venv/bin/activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up environment variables**
+   
+   Create a `.env` file in the project root:
+   ```bash
+   NEWSAPI_KEY=your_newsapi_key_here
+   ```
+
+## 🎯 Usage
+
+### Web Application
+
+Run the Streamlit app:
+```bash
+streamlit run streamlit_app.py
+```
+
+Then open your browser to `http://localhost:8501`
+
+### Command Line Interface
+
+For quick sentiment analysis:
+
+```bash
+# Basic usage
+python cli_demo.py
+
+# Custom search query
+python cli_demo.py --query "ChatGPT" --days 3
+
+# Filter to specific sources
+python cli_demo.py --sources "techcrunch,wired" --max-articles 5
+
+# Show only positive articles
+python cli_demo.py --positive-only
+
+# Show detailed sentiment analysis
+python cli_demo.py --sentiment-only
+```
+
+#### CLI Options
+- `--query, -q`: Search query (default: "artificial intelligence")
+- `--days, -d`: Days to look back (default: 7)
+- `--sources, -s`: Comma-separated news sources
+- `--max-articles, -m`: Maximum articles to display (default: 10)
+- `--positive-only`: Show only positive sentiment articles
+- `--negative-only`: Show only negative sentiment articles
+- `--sentiment-only`: Show only sentiment analysis summary
+
+## 🔧 Technical Architecture
+
+```mermaid
+flowchart TB
+    subgraph Frontend["🎨 Frontend Layer"]
+        A["🌐 Streamlit UI"]
+        B["💻 CLI Interface"]
+    end
+    
+    subgraph Application["⚙️ Application Layer"]
+        C["api_handler.py<br/>🔧 Core Logic"]
+        D["streamlit_app.py<br/>📊 Web Framework"]
+        E["cli_demo.py<br/>⌨️ Command Line"]
+    end
+    
+    subgraph Processing["🧠 Data Processing"]
+        F["TextBlob<br/>Sentiment Engine"]
+        G["Plotly<br/>Visualizations"]
+        H["Pandas<br/>Data Processing"]
+    end
+    
+    subgraph External["🌐 External Services"]
+        I["📡 NewsAPI<br/>TechCrunch, Wired, etc."]
+        J["🔐 Environment<br/>API Keys"]
+    end
+    
+    A --> D
+    B --> E
+    D --> C
+    E --> C
+    C --> F
+    C --> H
+    D --> G
+    C --> I
+    C --> J
+    
+    classDef frontend fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
+    classDef application fill:#fff3e0,stroke:#f57c00,stroke-width:2px
+    classDef processing fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
+    classDef external fill:#fce4ec,stroke:#c2185b,stroke-width:2px
+    
+    class A,B frontend
+    class C,D,E application
+    class F,G,H processing
+    class I,J external
+```
+
+## 📈 Example Output
+
+### CLI Example
+```bash
+🤖 AI News Sentiment Analyzer
+==================================================
+
+🔍 Searching for: "artificial intelligence"
+📅 Looking back: 7 days
+
+📰 Found 43 articles
+
+Sentiment Distribution:
+  😊 Positive: 18 articles (41.9%)
+  😐 Neutral: 15 articles (34.9%)
+  😞 Negative: 10 articles (23.2%)
+
+📄 Top 10 Articles:
+--------------------------------------------------------------------------------
+ 1. 😊 [TechCrunch] 2024-01-20 14:30
+    AI startup raises $50M for breakthrough in healthcare diagnosis
+    Sentiment: Positive (Score: 0.45)
+    📝 Revolutionary AI technology promises to transform medical diagnosis...
+    🔗 https://techcrunch.com/...
+
+ 2. 😞 [Reuters] 2024-01-20 12:15
+    Concerns grow over AI job displacement in manufacturing
+    Sentiment: Negative (Score: -0.32)
+    📝 Labor unions express worry about automation replacing workers...
+    🔗 https://reuters.com/...
+```
+
+## 🤝 Contributing
+
+This project was built as part of the Duke AIPI 503 Bootcamp.
+
+### Development Setup
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/some-feature`
+3. Make your changes and commit: `git commit -m 'Add some feature'`
+4. Push to the branch: `git push origin feature/some-feature`
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

requirements.txt

@@ -0,0 +1,7 @@
+streamlit>=1.28.0
+pandas>=2.0.0
+requests>=2.31.0
+python-dotenv>=1.0.0
+textblob>=0.17.1
+plotly>=5.15.0
+numpy>=1.24.0

src/api_handler.py

@@ -0,0 +1,269 @@
+"""
+AI News API Handler
+Fetches AI-related news from NewsAPI and performs sentiment analysis
+"""
+import requests
+import pandas as pd
+from datetime import datetime, timedelta
+import os
+from dotenv import load_dotenv
+from textblob import TextBlob
+from typing import List, Dict, Optional
+
+# Load environment variables
+load_dotenv()
+
+class AINewsAnalyzer:
+    def __init__(self):
+        self.api_key = os.getenv('NEWSAPI_KEY')
+        self.base_url = "https://newsapi.org/v2/everything"
+        
+        if not self.api_key:
+            raise ValueError("NewsAPI key not found. Please set NEWSAPI_KEY in your .env file")
+    
+    def fetch_ai_news(self, 
+                      query: str = "artificial intelligence", 
+                      days: int = 7, 
+                      language: str = "en",
+                      sources: Optional[str] = None,
+                      page_size: int = 100) -> List[Dict]:
+        """
+        Fetch AI-related news from NewsAPI
+        
+        Args:
+            query: Search query for news articles
+            days: Number of days to look back
+            language: Language code (default: "en")
+            sources: Comma-separated string of news sources
+            page_size: Number of articles to fetch (max 100)
+            
+        Returns:
+            List of news articles with metadata
+        """
+        # Calculate date range
+        to_date = datetime.now()
+        from_date = to_date - timedelta(days=days)
+        
+        # Prepare API parameters
+        params = {
+            'q': query,
+            'from': from_date.strftime('%Y-%m-%d'),
+            'to': to_date.strftime('%Y-%m-%d'),
+            'language': language,
+            'sortBy': 'publishedAt',
+            'pageSize': page_size,
+            'apiKey': self.api_key
+        }
+        
+        # Add sources if specified
+        if sources:
+            params['sources'] = sources
+        
+        try:
+            # Make API request
+            response = requests.get(self.base_url, params=params)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            if data['status'] == 'ok':
+                return data['articles']
+            else:
+                print(f"API Error: {data.get('message', 'Unknown error')}")
+                return []
+                
+        except requests.exceptions.RequestException as e:
+            print(f"Request failed: {e}")
+            return []
+    
+    def analyze_sentiment(self, text: str) -> Dict:
+        """
+        Analyze sentiment of given text using TextBlob
+        
+        Args:
+            text: Text to analyze
+            
+        Returns:
+            Dictionary with sentiment metrics
+        """
+        if not text:
+            return {
+                'polarity': 0.0,
+                'subjectivity': 0.0,
+                'label': 'neutral',
+                'confidence': 0.0
+            }
+        
+        blob = TextBlob(text)
+        polarity = blob.sentiment.polarity
+        subjectivity = blob.sentiment.subjectivity
+        
+        # Determine sentiment label
+        if polarity > 0.1:
+            label = 'positive'
+        elif polarity < -0.1:
+            label = 'negative'
+        else:
+            label = 'neutral'
+        
+        # Calculate confidence (distance from neutral)
+        confidence = abs(polarity)
+        
+        return {
+            'polarity': polarity,
+            'subjectivity': subjectivity,
+            'label': label,
+            'confidence': confidence
+        }
+    
+    def process_news_articles(self, articles: List[Dict]) -> pd.DataFrame:
+        """
+        Process news articles and add sentiment analysis
+        
+        Args:
+            articles: List of news articles from API
+            
+        Returns:
+            DataFrame with processed articles and sentiment data
+        """
+        processed_articles = []
+        
+        for article in articles:
+            # Skip articles with missing essential data
+            if not article.get('title') or not article.get('publishedAt'):
+                continue
+            
+            # Analyze sentiment of title and description
+            title_sentiment = self.analyze_sentiment(article['title'])
+            description_sentiment = self.analyze_sentiment(article.get('description', ''))
+            
+            # Combine title and description sentiment (weighted toward title)
+            combined_polarity = (title_sentiment['polarity'] * 0.7 + 
+                               description_sentiment['polarity'] * 0.3)
+            combined_subjectivity = (title_sentiment['subjectivity'] * 0.7 + 
+                                   description_sentiment['subjectivity'] * 0.3)
+            
+            # Determine overall sentiment
+            if combined_polarity > 0.1:
+                overall_sentiment = 'positive'
+            elif combined_polarity < -0.1:
+                overall_sentiment = 'negative'
+            else:
+                overall_sentiment = 'neutral'
+            
+            processed_article = {
+                'title': article['title'],
+                'description': article.get('description', ''),
+                'url': article['url'],
+                'source': article['source']['name'],
+                'published_at': article['publishedAt'],
+                'author': article.get('author', 'Unknown'),
+                'sentiment_label': overall_sentiment,
+                'sentiment_polarity': combined_polarity,
+                'sentiment_subjectivity': combined_subjectivity,
+                'title_sentiment': title_sentiment['label'],
+                'title_polarity': title_sentiment['polarity'],
+                'description_sentiment': description_sentiment['label'],
+                'description_polarity': description_sentiment['polarity']
+            }
+            
+            processed_articles.append(processed_article)
+        
+        # Convert to DataFrame
+        df = pd.DataFrame(processed_articles)
+        
+        # Convert published_at to datetime
+        if not df.empty:
+            df['published_at'] = pd.to_datetime(df['published_at'])
+            df = df.sort_values('published_at', ascending=False)
+        
+        return df
+    
+    def get_ai_news_with_sentiment(self, 
+                                   query: str = "artificial intelligence",
+                                   days: int = 7,
+                                   sources: Optional[str] = None) -> pd.DataFrame:
+        """
+        Complete pipeline: fetch news and analyze sentiment
+        
+        Args:
+            query: Search query for news articles
+            days: Number of days to look back
+            sources: Comma-separated string of news sources
+            
+        Returns:
+            DataFrame with news articles and sentiment analysis
+        """
+        print(f"Fetching {query} news from the last {days} days...")
+        
+        # Fetch articles
+        articles = self.fetch_ai_news(query=query, days=days, sources=sources)
+        
+        if not articles:
+            print("No articles found.")
+            return pd.DataFrame()
+        
+        print(f"Found {len(articles)} articles. Analyzing sentiment...")
+        
+        # Process and analyze
+        df = self.process_news_articles(articles)
+        
+        print(f"Processed {len(df)} articles with sentiment analysis.")
+        return df
+
+def fetch_ai_news(query="artificial intelligence", days=7, sources=None):
+    """Standalone function to fetch AI news"""
+    analyzer = AINewsAnalyzer()
+    return analyzer.fetch_ai_news(query, days, sources=sources)
+
+def analyze_sentiment(text):
+    """Standalone function to analyze sentiment"""
+    analyzer = AINewsAnalyzer()
+    return analyzer.analyze_sentiment(text)
+
+def get_ai_news_with_sentiment(query="artificial intelligence", days=7, sources=None):
+    """Standalone function for complete pipeline"""
+    analyzer = AINewsAnalyzer()
+    return analyzer.get_ai_news_with_sentiment(query, days, sources)
+
+if __name__ == "__main__":
+    # Test the API when run directly
+    analyzer = AINewsAnalyzer()
+    
+    print("Testing AI News Sentiment Analyzer...")
+    print("=" * 50)
+    
+    # Test sentiment analysis
+    test_texts = [
+        "AI breakthrough promises to revolutionize healthcare",
+        "Concerns grow over AI job displacement",
+        "New machine learning model shows mixed results"
+    ]
+    
+    print("\nSentiment Analysis Examples:")
+    for text in test_texts:
+        sentiment = analyzer.analyze_sentiment(text)
+        print(f"Text: {text}")
+        print(f"Sentiment: {sentiment['label']} (polarity: {sentiment['polarity']:.2f})")
+        print()
+    
+    # Test news fetching
+    print("Fetching recent AI news...")
+    df = analyzer.get_ai_news_with_sentiment(days=3)
+    
+    if not df.empty:
+        print(f"\nFound {len(df)} articles")
+        print("\nSentiment Distribution:")
+        print(df['sentiment_label'].value_counts())
+        
+        print("\nTop 3 Most Positive Headlines:")
+        positive_articles = df[df['sentiment_label'] == 'positive'].nlargest(3, 'sentiment_polarity')
+        for _, article in positive_articles.iterrows():
+            print(f"📈 {article['title']} (Score: {article['sentiment_polarity']:.2f})")
+        
+        print("\nTop 3 Most Negative Headlines:")
+        negative_articles = df[df['sentiment_label'] == 'negative'].nsmallest(3, 'sentiment_polarity')
+        for _, article in negative_articles.iterrows():
+            print(f"📉 {article['title']} (Score: {article['sentiment_polarity']:.2f})")
+    else:
+        print("No articles found. Check your API key and internet connection.")

src/cli_demo.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+CLI Demo for AI News Sentiment Analyzer
+Demonstrates the functionality via command line interface
+"""
+
+import argparse
+import sys
+from datetime import datetime
+from api_handler import AINewsAnalyzer
+
+def print_header():
+    """Print a nice header for the CLI"""
+    print("🤖 AI News Sentiment Analyzer")
+    print("=" * 50)
+    print()
+
+def print_sentiment_emoji(sentiment):
+    """Return emoji based on sentiment"""
+    emoji_map = {
+        'positive': '😊',
+        'negative': '😞',
+        'neutral': '😐'
+    }
+    return emoji_map.get(sentiment, '🤷')
+
+def display_articles(df, max_articles=10):
+    """Display articles in a formatted way"""
+    if df.empty:
+        print("❌ No articles found.")
+        return
+    
+    print(f"📰 Found {len(df)} articles")
+    print("\nSentiment Distribution:")
+    sentiment_counts = df['sentiment_label'].value_counts()
+    for sentiment, count in sentiment_counts.items():
+        emoji = print_sentiment_emoji(sentiment)
+        percentage = (count / len(df)) * 100
+        print(f"  {emoji} {sentiment.title()}: {count} articles ({percentage:.1f}%)")
+    
+    print(f"\n📄 Top {min(max_articles, len(df))} Articles:")
+    print("-" * 80)
+    
+    for idx, (_, article) in enumerate(df.head(max_articles).iterrows(), 1):
+        sentiment_emoji = print_sentiment_emoji(article['sentiment_label'])
+        score = article['sentiment_polarity']
+        published = article['published_at'].strftime('%Y-%m-%d %H:%M')
+        
+        print(f"{idx:2}. {sentiment_emoji} [{article['source']}] {published}")
+        print(f"    {article['title']}")
+        print(f"    Sentiment: {article['sentiment_label'].title()} (Score: {score:.2f})")
+        if article['description'] and len(article['description']) > 100:
+            description = article['description'][:100] + "..."
+        else:
+            description = article['description'] or "No description available"
+        print(f"    📝 {description}")
+        print(f"    🔗 {article['url']}")
+        print()
+
+def display_sentiment_analysis(df):
+    """Display detailed sentiment analysis"""
+    if df.empty:
+        return
+    
+    print("\n📊 Sentiment Analysis Summary:")
+    print("-" * 40)
+    
+    # Overall statistics
+    avg_polarity = df['sentiment_polarity'].mean()
+    avg_subjectivity = df['sentiment_subjectivity'].mean()
+    
+    print(f"Average Polarity: {avg_polarity:.3f} (Range: -1.0 to +1.0)")
+    print(f"Average Subjectivity: {avg_subjectivity:.3f} (Range: 0.0 to 1.0)")
+    
+    if avg_polarity > 0.1:
+        overall_mood = "📈 Generally Positive"
+    elif avg_polarity < -0.1:
+        overall_mood = "📉 Generally Negative"
+    else:
+        overall_mood = "➡️ Generally Neutral"
+    
+    print(f"Overall Mood: {overall_mood}")
+    
+    # Most positive and negative articles
+    if len(df[df['sentiment_label'] == 'positive']) > 0:
+        most_positive = df.loc[df['sentiment_polarity'].idxmax()]
+        print(f"\n😊 Most Positive: \"{most_positive['title']}\" ({most_positive['sentiment_polarity']:.2f})")
+    
+    if len(df[df['sentiment_label'] == 'negative']) > 0:
+        most_negative = df.loc[df['sentiment_polarity'].idxmin()]
+        print(f"😞 Most Negative: \"{most_negative['title']}\" ({most_negative['sentiment_polarity']:.2f})")
+
+def display_sources(df):
+    """Display source breakdown"""
+    if df.empty:
+        return
+    
+    print("\n📺 News Sources:")
+    print("-" * 30)
+    source_counts = df['source'].value_counts()
+    for source, count in source_counts.head(10).items():
+        print(f"  📰 {source}: {count} articles")
+
+def main():
+    parser = argparse.ArgumentParser(description='AI News Sentiment Analyzer CLI Demo')
+    parser.add_argument('--query', '-q', 
+                       default='artificial intelligence',
+                       help='Search query for news articles (default: "artificial intelligence")')
+    parser.add_argument('--days', '-d', 
+                       type=int, 
+                       default=7,
+                       help='Number of days to look back (default: 7)')
+    parser.add_argument('--sources', '-s',
+                       help='Comma-separated list of news sources (e.g., "techcrunch,wired")')
+    parser.add_argument('--max-articles', '-m',
+                       type=int,
+                       default=10,
+                       help='Maximum number of articles to display (default: 10)')
+    parser.add_argument('--sentiment-only', 
+                       action='store_true',
+                       help='Show only sentiment analysis summary')
+    parser.add_argument('--positive-only',
+                       action='store_true', 
+                       help='Show only positive articles')
+    parser.add_argument('--negative-only',
+                       action='store_true',
+                       help='Show only negative articles')
+    
+    args = parser.parse_args()
+    
+    print_header()
+    
+    try:
+        # Initialize analyzer
+        analyzer = AINewsAnalyzer()
+        
+        print(f"🔍 Searching for: \"{args.query}\"")
+        print(f"📅 Looking back: {args.days} days")
+        if args.sources:
+            print(f"📰 Sources: {args.sources}")
+        print()
+        
+        # Fetch and analyze news
+        df = analyzer.get_ai_news_with_sentiment(
+            query=args.query,
+            days=args.days,
+            sources=args.sources
+        )
+        
+        if df.empty:
+            print("❌ No articles found. Try adjusting your search parameters.")
+            return
+        
+        # Filter by sentiment if requested
+        if args.positive_only:
+            df = df[df['sentiment_label'] == 'positive']
+            print("🔽 Filtered to show only POSITIVE articles")
+        elif args.negative_only:
+            df = df[df['sentiment_label'] == 'negative']
+            print("🔽 Filtered to show only NEGATIVE articles")
+        
+        # Display results based on options
+        if args.sentiment_only:
+            display_sentiment_analysis(df)
+        else:
+            display_articles(df, args.max_articles)
+            display_sentiment_analysis(df)
+            display_sources(df)
+        
+        print(f"\n✅ Analysis complete! Processed {len(df)} articles.")
+        
+    except KeyboardInterrupt:
+        print("\n👋 Analysis interrupted by user.")
+        sys.exit(0)
+    except Exception as e:
+        print(f"❌ Error occurred: {e}")
+        print("Please check your API key and internet connection.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

src/streamlit_app.py

@@ -0,0 +1,277 @@
+"""
+AI News Sentiment Analyzer - Streamlit Web Application
+Interactive dashboard for analyzing sentiment of AI-related news
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from api_handler import AINewsAnalyzer
+
+# Page configuration
+st.set_page_config(
+    page_title="AI News Sentiment Analyzer",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 5px solid #1f77b4;
+    }
+    .positive { color: #28a745; }
+    .negative { color: #dc3545; }
+    .neutral { color: #6c757d; }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_data(ttl=1800)  # Cache for 30 minutes
+def load_news_data(query, days, sources=None):
+    """Load and cache news data"""
+    try:
+        analyzer = AINewsAnalyzer()
+        df = analyzer.get_ai_news_with_sentiment(query=query, days=days, sources=sources)
+        return df, None
+    except Exception as e:
+        return pd.DataFrame(), str(e)
+
+
+def create_sentiment_distribution(df):
+    """Create sentiment distribution pie chart"""
+    if df.empty:
+        return None
+    
+    sentiment_counts = df['sentiment_label'].value_counts()
+    
+    fig = px.pie(
+        values=sentiment_counts.values,
+        names=sentiment_counts.index,
+        title="🎯 Sentiment Distribution",
+        color_discrete_map={
+            'positive': '#28a745',
+            'negative': '#dc3545',
+            'neutral': '#6c757d'
+        }
+    )
+    
+    fig.update_traces(textposition='inside', textinfo='percent+label')
+    return fig
+
+def create_source_analysis(df):
+    """Create source analysis chart"""
+    if df.empty:
+        return None
+    
+    source_sentiment = df.groupby(['source', 'sentiment_label']).size().unstack(fill_value=0)
+    source_sentiment = source_sentiment.loc[source_sentiment.sum(axis=1).nlargest(10).index]
+    
+    fig = px.bar(
+        source_sentiment.reset_index(),
+        x='source',
+        y=['positive', 'negative', 'neutral'],
+        title="📰 Sentiment by News Source (Top 10)",
+        color_discrete_map={
+            'positive': '#28a745',
+            'negative': '#dc3545',
+            'neutral': '#6c757d'
+        }
+    )
+    
+    fig.update_layout(
+        xaxis_title="News Source",
+        yaxis_title="Number of Articles",
+        xaxis_tickangle=-45
+    )
+    
+    return fig
+
+def create_polarity_distribution(df):
+    """Create sentiment polarity distribution"""
+    if df.empty:
+        return None
+    
+    fig = px.histogram(
+        df,
+        x='sentiment_polarity',
+        nbins=30,
+        title="📊 Sentiment Polarity Distribution",
+        labels={'sentiment_polarity': 'Sentiment Polarity', 'count': 'Number of Articles'}
+    )
+    
+    # Add vertical lines for sentiment boundaries
+    fig.add_vline(x=0.1, line_dash="dash", line_color="green", annotation_text="Positive Threshold")
+    fig.add_vline(x=-0.1, line_dash="dash", line_color="red", annotation_text="Negative Threshold")
+    fig.add_vline(x=0, line_dash="dash", line_color="gray", annotation_text="Neutral")
+    
+    return fig
+
+
+def main():
+    # Header
+    st.markdown("<h1 class='main-header'>🤖 AI News Sentiment Analyzer</h1>", unsafe_allow_html=True)
+    st.markdown("### Discover the sentiment trends in AI-related news from around the world")
+    
+    # Sidebar controls
+    st.sidebar.header("🔧 Analysis Settings")
+    
+    # Query input
+    query_options = [
+        "artificial intelligence",
+        "machine learning", 
+        "ChatGPT",
+        "OpenAI",
+        "deep learning",
+        "neural networks",
+        "AI ethics",
+        "robotics",
+        "computer vision",
+        "natural language processing"
+    ]
+    
+    selected_query = st.sidebar.selectbox(
+        "📝 Search Topic:",
+        options=query_options,
+        index=0
+    )
+    
+    custom_query = st.sidebar.text_input(
+        "Or enter custom search:",
+        placeholder="e.g., 'generative AI'"
+    )
+    
+    # Use custom query if provided
+    final_query = custom_query if custom_query else selected_query
+    
+    # Time range
+    days = st.sidebar.slider(
+        "📅 Days to analyze:",
+        min_value=1,
+        max_value=30,
+        value=7,
+        help="How many days back to search for news"
+    )
+    
+    # News sources (confirmed available in NewsAPI)
+    popular_sources = [
+        "techcrunch,wired,ars-technica,the-verge,engadget",
+        "reuters,associated-press,bbc-news",
+        "cnn,fox-news,abc-news", 
+        "financial-times,wall-street-journal,bloomberg"
+    ]
+    
+    source_option = st.sidebar.selectbox(
+        "📰 Source Category:",
+        options=["All Sources", "Tech Media", "General News", "US News", "Financial News"],
+        index=0
+    )
+    
+    if source_option == "Tech Media":
+        sources = popular_sources[0]
+    elif source_option == "General News":
+        sources = popular_sources[1]
+    elif source_option == "US News":
+        sources = popular_sources[2]
+    elif source_option == "Financial News":
+        sources = popular_sources[3]
+    else:
+        sources = None
+    
+    # Load data
+    if st.sidebar.button("🚀 Analyze News", type="primary"):
+        with st.spinner(f"Fetching and analyzing news about '{final_query}'..."):
+            df, error = load_news_data(final_query, days, sources)
+            
+            if error:
+                st.error(f"Error loading data: {error}")
+                st.stop()
+            
+            if df.empty:
+                st.warning("No articles found. Try adjusting your search parameters.")
+                st.stop()
+            
+            # Store results in session state
+            st.session_state.df = df
+            st.session_state.query = final_query
+            st.session_state.days = days
+    
+    # Display results if data is available
+    if 'df' in st.session_state:
+        df = st.session_state.df
+        
+        # Summary metrics
+        st.markdown("### 📊 Analysis Summary")
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("📰 Total Articles", len(df))
+        
+        with col2:
+            avg_polarity = df['sentiment_polarity'].mean()
+            delta_polarity = f"{avg_polarity:+.3f}"
+            st.metric("🎭 Avg Sentiment", f"{avg_polarity:.3f}", delta_polarity)
+        
+        with col3:
+            positive_pct = (len(df[df['sentiment_label'] == 'positive']) / len(df) * 100)
+            st.metric("😊 Positive %", f"{positive_pct:.1f}%")
+        
+        with col4:
+            unique_sources = df['source'].nunique()
+            st.metric("📺 News Sources", unique_sources)
+        
+        # Charts
+        st.markdown("### 📈 Visual Analysis")
+        
+        # Row 1: Distribution and source analysis
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            dist_fig = create_sentiment_distribution(df)
+            if dist_fig:
+                st.plotly_chart(dist_fig, use_container_width=True)
+        
+        with col2:
+            source_fig = create_source_analysis(df)
+            if source_fig:
+                st.plotly_chart(source_fig, use_container_width=True)
+        
+        # Row 2: Polarity distribution (full width)
+        polarity_fig = create_polarity_distribution(df)
+        if polarity_fig:
+            st.plotly_chart(polarity_fig, use_container_width=True)
+        
+    
+    else:
+        # Welcome message
+        st.info("👋 Welcome! Configure your analysis settings in the sidebar and click 'Analyze News' to get started.")
+        
+        # Sample visualization or instructions
+        st.markdown("""
+        ### 🚀 How to Use:
+        
+        1. **Choose a topic** from the dropdown or enter your own search term
+        2. **Select time range** (1-30 days) to analyze recent news
+        3. **Pick news sources** or leave as 'All Sources' for comprehensive coverage
+        4. **Click 'Analyze News'** to fetch and analyze articles
+        
+        ### 📊 What You'll Get:
+        
+        - **Sentiment Analysis** of headlines and descriptions
+        - **Interactive Charts** showing trends over time
+        - **Source Breakdown** to see which outlets cover your topic
+        """)
+
+if __name__ == "__main__":
+    main()