Add Prime Bank Analytics Dashboard

.gitignore

@@ -0,0 +1,31 @@
+# Environment variables
+.env
+.env.local
+
+# Data files
+*.csv
+*.txt
+data/raw/*
+data/processed/*
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Streamlit
+.streamlit/secrets.toml
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Keep empty directories
+!data/raw/.gitkeep
+!data/processed/.gitkeep

app.py

@@ -0,0 +1,204 @@
+import streamlit as st
+import pandas as pd
+from src.data_processor import DataProcessor
+from src.visualizations import *
+
+# Page config
+st.set_page_config(
+    page_title="Prime Bank Analytics Dashboard",
+    page_icon="🏦",
+    layout="wide"
+)
+
+# Title
+st.title("🏦 Prime Bank Social Media Analytics Dashboard")
+
+# Sidebar for configuration
+with st.sidebar:
+    st.header("⚙️ Configuration")
+    
+    # API Key input
+    api_key = st.text_input(
+        "OpenAI API Key (optional):", 
+        type="password",
+        help="Enter your OpenAI API key for advanced GPT analysis"
+    )
+    
+    if api_key:
+        st.success("✅ API Key configured")
+        use_gpt = st.checkbox("Enable GPT Analysis", value=True)
+    else:
+        st.info("💡 Running without GPT features")
+        use_gpt = False
+    
+    st.markdown("---")
+    st.markdown("### About")
+    st.markdown("Upload CSV files from social media platforms and TXT files with reviews to analyze Prime Bank's online presence.")
+
+# Initialize processor with or without API key
+processor = DataProcessor(openai_api_key=api_key if use_gpt else None)
+
+# Main content
+st.markdown("### 📁 Upload Your Data Files")
+
+# File upload section
+col1, col2 = st.columns(2)
+
+with col1:
+    csv_files = st.file_uploader(
+        "Upload CSV files (Facebook, Twitter, etc.)",
+        type=['csv'],
+        accept_multiple_files=True,
+        help="Upload one or more CSV files containing social media data"
+    )
+
+with col2:
+    txt_file = st.file_uploader(
+        "Upload TXT file (Manual reviews)",
+        type=['txt'],
+        help="Upload a text file with reviews, one per line"
+    )
+
+# Add sample data download option
+with st.expander("📝 Need sample data to test?"):
+    st.markdown("""
+    Download these sample files to test the dashboard:
+    - [Sample CSV Data](https://example.com)
+    - [Sample TXT Reviews](https://example.com)
+    
+    Or create test data by running:
+    ```bash
+    python create_test_data.py
+    ```
+    """)
+
+# Process files when uploaded
+if csv_files or txt_file:
+    with st.spinner('Processing files...'):
+        all_data = []
+        
+        # Process CSV files
+        if csv_files:
+            st.write(f"📊 Processing {len(csv_files)} CSV file(s)...")
+            csv_data = processor.process_csv_files(csv_files)
+            if not csv_data.empty:
+                all_data.append(csv_data)
+                st.success(f"✅ Loaded {len(csv_data)} rows from CSV files")
+        
+        # Process TXT file
+        if txt_file:
+            st.write("📝 Processing TXT file...")
+            txt_data = processor.process_txt_file(txt_file)
+            if not txt_data.empty:
+                all_data.append(txt_data)
+                st.success(f"✅ Loaded {len(txt_data)} reviews from TXT file")
+        
+        # Combine all data
+        if all_data:
+            combined_df = pd.concat(all_data, ignore_index=True)
+            
+            # Process the data
+            with st.spinner('Analyzing sentiment and emotions...'):
+                processed_df = processor.process_all_data(combined_df)
+            
+            # Filter for Prime Bank mentions
+            prime_df = processed_df[processed_df['prime_mentions'] > 0]
+            
+            st.success(f"✅ Analysis complete! Found {len(prime_df)} posts mentioning Prime Bank out of {len(processed_df)} total posts")
+            
+            # Display metrics
+            st.header("📊 Key Metrics")
+            metrics = create_summary_metrics(processed_df)
+            
+            col1, col2, col3, col4 = st.columns(4)
+            for i, (label, value) in enumerate(metrics.items()):
+                with [col1, col2, col3, col4][i]:
+                    st.metric(label, value)
+            
+            # Display charts
+            st.header("📈 Analysis")
+            
+            # First row of charts
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if len(prime_df) > 0:
+                    fig = create_sentiment_pie(prime_df)
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.info("No Prime Bank mentions found for sentiment analysis")
+            
+            with col2:
+                if len(prime_df) > 0:
+                    fig = create_emotion_bar(prime_df)
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.info("No Prime Bank mentions found for emotion analysis")
+            
+            with col3:
+                if len(prime_df) > 0:
+                    fig = create_category_donut(prime_df)
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.info("No Prime Bank mentions found for category analysis")
+            
+            # Top Viral Posts
+            st.header("🔥 Top Viral Posts Mentioning Prime Bank")
+            
+            if len(prime_df) > 0:
+                top_posts = prime_df.nlargest(5, 'viral_score')[['text', 'sentiment', 'emotion', 'category', 'prime_mentions']]
+                
+                for idx, row in top_posts.iterrows():
+                    with st.expander(f"Post #{idx+1} - {row['sentiment']} | {row['emotion']}"):
+                        st.write(row['text'])
+                        col1, col2, col3, col4 = st.columns(4)
+                        col1.metric("Sentiment", row['sentiment'])
+                        col2.metric("Emotion", row['emotion'])
+                        col3.metric("Category", row['category'])
+                        col4.metric("Mentions", row['prime_mentions'])
+            else:
+                st.info("No posts mentioning Prime Bank found")
+            
+            # Data table
+            with st.expander("📋 View All Data"):
+                st.dataframe(processed_df)
+            
+            # Download processed data
+            csv = processed_df.to_csv(index=False)
+            st.download_button(
+                label="📥 Download Processed Data",
+                data=csv,
+                file_name="prime_bank_analysis.csv",
+                mime="text/csv"
+            )
+
+else:
+    # No files uploaded yet
+    st.info("👆 Please upload CSV files and/or TXT file to begin analysis")
+    
+    # Show instructions
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        ### 📊 CSV Files Should Contain:
+        - A text column (text/content/message)
+        - Optional: date, likes, shares
+        - Can upload multiple files
+        """)
+    
+    with col2:
+        st.markdown("""
+        ### 📝 TXT File Format:
+        - One review per line
+        - Plain text format
+        - Manual reviews/comments
+        """)
+    
+    with col3:
+        st.markdown("""
+        ### 🎯 Analysis Includes:
+        - Sentiment (Positive/Negative)
+        - Emotions (Joy/Frustration)
+        - Categories (Inquiry/Complaint)
+        """)

create_test_data.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+# Create sample CSV data
+sample_data = pd.DataFrame({
+    'text': [
+        'Prime Bank has the best customer service! Love their mobile app.',
+        'Worst experience at Prime Bank branch today. Waited 2 hours!',
+        'How do I apply for a loan at Prime Bank?',
+        'Prime Bank ATM is not working again. So frustrated!',
+        'Thank you Prime Bank staff for helping with my account.',
+        'What are Prime Bank interest rates?',
+        'Prime Bank online banking is confusing.',
+        'Excellent service at Prime Bank downtown branch!',
+        'Prime Bank charged me hidden fees. Very disappointed.',
+        'Can someone explain Prime Bank credit card benefits?'
+    ],
+    'date': pd.date_range('2024-01-01', periods=10),
+    'likes': [45, 12, 5, 89, 34, 8, 15, 67, 102, 22],
+    'shares': [5, 2, 1, 15, 8, 1, 3, 12, 25, 4]
+})
+
+# Save as CSV
+sample_data.to_csv('test_social_media_data.csv', index=False)
+print("✅ Created test_social_media_data.csv")
+
+# Create sample TXT file with reviews
+reviews = """Prime Bank provides exceptional service. Highly recommend!
+Terrible experience with Prime Bank customer support.
+Prime Bank mobile app keeps crashing. Please fix this!
+Love the new features in Prime Bank online banking.
+Why does Prime Bank charge so many fees?"""
+
+with open('test_reviews.txt', 'w') as f:
+    f.write(reviews)
+print("✅ Created test_reviews.txt")

src/data_processor.py

@@ -0,0 +1,205 @@
+import pandas as pd
+import re
+from textblob import TextBlob
+import numpy as np
+import json
+
+# Try to import optional dependencies
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    print("OpenAI not installed. GPT features will be disabled.")
+
+try:
+    import nltk
+    from nltk.sentiment import SentimentIntensityAnalyzer
+    nltk.download('vader_lexicon', quiet=True)
+    NLTK_AVAILABLE = True
+except ImportError:
+    NLTK_AVAILABLE = False
+    print("NLTK not installed. Using TextBlob only.")
+
+class DataProcessor:
+    def __init__(self, openai_api_key=None):
+        self.processed_data = None
+        
+        # Initialize VADER if available
+        if NLTK_AVAILABLE:
+            try:
+                self.sia = SentimentIntensityAnalyzer()
+            except:
+                self.sia = None
+        else:
+            self.sia = None
+            
+        # Set up OpenAI if key provided and library available
+        self.use_gpt = False
+        if openai_api_key and OPENAI_AVAILABLE:
+            openai.api_key = openai_api_key
+            self.use_gpt = True
+            
+        # Banking-specific patterns
+        self.banking_keywords = {
+            'service_quality': ['customer service', 'staff', 'support', 'help', 'assistance'],
+            'transaction': ['transfer', 'deposit', 'withdraw', 'payment', 'transaction'],
+            'account': ['account', 'savings', 'checking', 'balance'],
+            'loan': ['loan', 'mortgage', 'credit', 'interest rate'],
+            'digital': ['app', 'online banking', 'mobile', 'website', 'digital'],
+            'branch': ['branch', 'atm', 'location', 'queue', 'waiting']
+        }
+        
+    def process_csv_files(self, uploaded_files):
+        """Process multiple CSV files"""
+        all_dataframes = []
+        
+        for uploaded_file in uploaded_files:
+            try:
+                df = pd.read_csv(uploaded_file)
+                df['source_file'] = uploaded_file.name
+                all_dataframes.append(df)
+            except Exception as e:
+                print(f"Error reading {uploaded_file.name}: {e}")
+        
+        if all_dataframes:
+            combined_df = pd.concat(all_dataframes, ignore_index=True)
+            return combined_df
+        return pd.DataFrame()
+    
+    def process_txt_file(self, txt_file):
+        """Process text file with reviews"""
+        content = txt_file.read().decode('utf-8')
+        reviews = content.split('\n')
+        
+        df = pd.DataFrame({
+            'text': [review.strip() for review in reviews if review.strip()],
+            'source_file': txt_file.name
+        })
+        return df
+    
+    def analyze_sentiment(self, text):
+        """Analyze sentiment - use VADER if available, else TextBlob"""
+        if pd.isna(text) or str(text).strip() == '':
+            return 'Neutral', 0
+        
+        text_str = str(text)
+        
+        # Try VADER first if available
+        if self.sia:
+            scores = self.sia.polarity_scores(text_str)
+            compound = scores['compound']
+            
+            if compound >= 0.05:
+                return 'Positive', compound
+            elif compound <= -0.05:
+                return 'Negative', compound
+            else:
+                return 'Neutral', compound
+        
+        # Fallback to TextBlob
+        try:
+            blob = TextBlob(text_str)
+            polarity = blob.sentiment.polarity
+            
+            if polarity > 0.1:
+                return 'Positive', polarity
+            elif polarity < -0.1:
+                return 'Negative', polarity
+            else:
+                return 'Neutral', polarity
+        except:
+            return 'Neutral', 0
+    
+    def detect_emotion(self, text):
+        """Detect emotion in text"""
+        if pd.isna(text):
+            return 'Neutral'
+        
+        text_lower = str(text).lower()
+        
+        # Emotion keywords
+        emotions = {
+            'Joy': ['happy', 'excellent', 'amazing', 'great', 'wonderful', 'fantastic', 'love', 'best', 'thank you'],
+            'Frustration': ['frustrated', 'angry', 'terrible', 'horrible', 'worst', 'hate', 'annoyed', 'disappointed'],
+            'Confusion': ['confused', 'unclear', "don't understand", 'what', 'how', 'why', '?', 'help me']
+        }
+        
+        emotion_scores = {}
+        for emotion, keywords in emotions.items():
+            score = sum(keyword in text_lower for keyword in keywords)
+            emotion_scores[emotion] = score
+        
+        if max(emotion_scores.values()) > 0:
+            return max(emotion_scores, key=emotion_scores.get)
+        return 'Neutral'
+    
+    def categorize_post(self, text):
+        """Categorize post type"""
+        if pd.isna(text):
+            return 'Other'
+        
+        text_lower = str(text).lower()
+        
+        if '?' in text_lower or any(word in text_lower for word in ['how', 'what', 'when', 'where']):
+            return 'Inquiry'
+        elif any(word in text_lower for word in ['complaint', 'problem', 'issue', 'bad', 'terrible']):
+            return 'Complaint'
+        elif any(word in text_lower for word in ['thank', 'great', 'excellent', 'love', 'best']):
+            return 'Praise'
+        else:
+            return 'Other'
+    
+    def count_prime_mentions(self, text):
+        """Count Prime Bank mentions"""
+        if pd.isna(text):
+            return 0
+        
+        text_lower = str(text).lower()
+        patterns = [
+            r'prime\s*bank',
+            r'primebank',
+            r'@primebank'
+        ]
+        
+        total_mentions = 0
+        for pattern in patterns:
+            mentions = len(re.findall(pattern, text_lower))
+            total_mentions += mentions
+            
+        return total_mentions
+    
+    def process_all_data(self, df):
+        """Apply all processing to dataframe"""
+        # Find text column
+        text_columns = ['text', 'content', 'message', 'review', 'comment', 'post']
+        text_col = None
+        
+        for col in text_columns:
+            if col in df.columns:
+                text_col = col
+                break
+        
+        if text_col and text_col != 'text':
+            df['text'] = df[text_col]
+        
+        if 'text' not in df.columns:
+            return df
+        
+        # Apply all analyses
+        df[['sentiment', 'polarity']] = df['text'].apply(
+            lambda x: pd.Series(self.analyze_sentiment(x))
+        )
+        
+        df['emotion'] = df['text'].apply(self.detect_emotion)
+        df['category'] = df['text'].apply(self.categorize_post)
+        df['prime_mentions'] = df['text'].apply(self.count_prime_mentions)
+        
+        # Calculate viral score
+        df['viral_score'] = df['prime_mentions'] * 10
+        if 'likes' in df.columns:
+            df['viral_score'] += df['likes'].fillna(0)
+        if 'shares' in df.columns:
+            df['viral_score'] += df['shares'].fillna(0) * 2
+            
+        return df

src/visualizations.py

@@ -0,0 +1,380 @@
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+
+def create_sentiment_pie(df):
+    """Create sentiment distribution pie chart"""
+    sentiment_counts = df['sentiment'].value_counts()
+    
+    fig = px.pie(
+        values=sentiment_counts.values,
+        names=sentiment_counts.index,
+        title="Sentiment Distribution",
+        color_discrete_map={
+            'Positive': '#2ecc71',
+            'Negative': '#e74c3c',
+            'Neutral': '#95a5a6'
+        }
+    )
+    
+    fig.update_traces(
+        textposition='inside',
+        textinfo='percent+label',
+        hovertemplate='<b>%{label}</b><br>Count: %{value}<br>Percentage: %{percent}<extra></extra>'
+    )
+    
+    return fig
+
+def create_emotion_bar(df):
+    """Create emotion distribution bar chart"""
+    emotion_counts = df['emotion'].value_counts()
+    
+    # Define colors for emotions
+    color_map = {
+        'Joy': '#f39c12',
+        'Frustration': '#e74c3c',
+        'Confusion': '#3498db',
+        'Anxiety': '#9b59b6',
+        'Neutral': '#95a5a6'
+    }
+    
+    colors = [color_map.get(emotion, '#95a5a6') for emotion in emotion_counts.index]
+    
+    fig = px.bar(
+        x=emotion_counts.index,
+        y=emotion_counts.values,
+        title="Emotion Detection",
+        labels={'x': 'Emotion', 'y': 'Count'},
+        color=emotion_counts.index,
+        color_discrete_map=color_map
+    )
+    
+    fig.update_layout(
+        showlegend=False,
+        xaxis_tickangle=-45,
+        yaxis=dict(gridcolor='rgba(0,0,0,0.1)')
+    )
+    
+    return fig
+
+def create_category_donut(df):
+    """Create post category donut chart"""
+    category_counts = df['category'].value_counts()
+    
+    # Define colors for categories
+    color_sequence = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']
+    
+    fig = px.pie(
+        values=category_counts.values,
+        names=category_counts.index,
+        title="Post Categories",
+        hole=0.4,
+        color_discrete_sequence=color_sequence
+    )
+    
+    # Add text in center
+    fig.update_traces(
+        textposition='inside',
+        textinfo='percent+label',
+        hovertemplate='<b>%{label}</b><br>Count: %{value}<br>Percentage: %{percent}<extra></extra>'
+    )
+    
+    # Add annotation in center
+    fig.add_annotation(
+        text=f"Total<br>{len(df)}",
+        x=0.5, y=0.5,
+        xref="paper", yref="paper",
+        showarrow=False,
+        font=dict(size=20)
+    )
+    
+    return fig
+
+def create_mentions_timeline(df):
+    """Create timeline of Prime Bank mentions if date column exists"""
+    date_columns = ['date', 'created_at', 'timestamp', 'Date', 'post_date']
+    date_col = None
+    
+    # Find date column
+    for col in date_columns:
+        if col in df.columns:
+            date_col = col
+            break
+    
+    if not date_col:
+        return None
+    
+    try:
+        # Parse dates
+        df['date_parsed'] = pd.to_datetime(df[date_col], errors='coerce')
+        
+        # Remove invalid dates
+        df_valid = df[df['date_parsed'].notna()]
+        
+        if len(df_valid) == 0:
+            return None
+        
+        # Group by date
+        timeline_df = df_valid.groupby(df_valid['date_parsed'].dt.date).agg({
+            'prime_mentions': 'sum',
+            'sentiment': lambda x: (x == 'Positive').sum()
+        }).reset_index()
+        
+        timeline_df.columns = ['date', 'mentions', 'positive_posts']
+        
+        # Create figure with secondary y-axis
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+        
+        # Add mentions line
+        fig.add_trace(
+            go.Scatter(
+                x=timeline_df['date'],
+                y=timeline_df['mentions'],
+                name='Total Mentions',
+                line=dict(color='#3498db', width=3),
+                mode='lines+markers'
+            ),
+            secondary_y=False,
+        )
+        
+        # Add positive posts line
+        fig.add_trace(
+            go.Scatter(
+                x=timeline_df['date'],
+                y=timeline_df['positive_posts'],
+                name='Positive Posts',
+                line=dict(color='#2ecc71', width=2, dash='dot'),
+                mode='lines+markers'
+            ),
+            secondary_y=True,
+        )
+        
+        # Update layout
+        fig.update_xaxes(title_text="Date")
+        fig.update_yaxes(title_text="Number of Mentions", secondary_y=False)
+        fig.update_yaxes(title_text="Positive Posts", secondary_y=True)
+        
+        fig.update_layout(
+            title="Prime Bank Mentions Over Time",
+            hovermode='x unified',
+            showlegend=True,
+            legend=dict(
+                yanchor="top",
+                y=0.99,
+                xanchor="left",
+                x=0.01
+            )
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Error creating timeline: {e}")
+        return None
+
+def create_summary_metrics(df):
+    """Calculate summary metrics for display"""
+    total_posts = len(df)
+    prime_posts = len(df[df['prime_mentions'] > 0])
+    total_mentions = df['prime_mentions'].sum()
+    
+    # Calculate positive sentiment rate
+    if prime_posts > 0:
+        prime_df = df[df['prime_mentions'] > 0]
+        positive_rate = (prime_df['sentiment'] == 'Positive').sum() / prime_posts * 100
+    else:
+        positive_rate = 0
+    
+    metrics = {
+        'Total Posts Analyzed': f"{total_posts:,}",
+        'Posts Mentioning Prime Bank': f"{prime_posts:,}",
+        'Total Prime Bank Mentions': f"{total_mentions:,}",
+        'Positive Sentiment Rate': f"{positive_rate:.1f}%"
+    }
+    
+    return metrics
+
+def create_viral_posts_chart(df, top_n=10):
+    """Create horizontal bar chart of most viral posts"""
+    # Get top viral posts
+    top_viral = df.nlargest(top_n, 'viral_score')
+    
+    # Truncate text for display
+    top_viral['text_truncated'] = top_viral['text'].apply(
+        lambda x: x[:50] + '...' if len(str(x)) > 50 else x
+    )
+    
+    # Create horizontal bar chart
+    fig = px.bar(
+        top_viral,
+        x='viral_score',
+        y='text_truncated',
+        orientation='h',
+        title=f'Top {top_n} Viral Posts',
+        color='sentiment',
+        color_discrete_map={
+            'Positive': '#2ecc71',
+            'Negative': '#e74c3c',
+            'Neutral': '#95a5a6'
+        },
+        hover_data=['text', 'emotion', 'category']
+    )
+    
+    fig.update_layout(
+        yaxis={'categoryorder': 'total ascending'},
+        xaxis_title="Viral Score",
+        yaxis_title="Post Preview",
+        showlegend=True
+    )
+    
+    return fig
+
+def create_word_frequency_chart(df, top_n=15):
+    """Create word frequency chart for Prime Bank posts"""
+    from collections import Counter
+    import re
+    
+    # Get only Prime Bank posts
+    prime_posts = df[df['prime_mentions'] > 0]['text'].dropna()
+    
+    if len(prime_posts) == 0:
+        return None
+    
+    # Combine all text
+    all_text = ' '.join(prime_posts.astype(str)).lower()
+    
+    # Remove common words and Prime Bank itself
+    stop_words = {
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+        'of', 'with', 'is', 'was', 'are', 'were', 'been', 'be', 'have', 'has',
+        'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may',
+        'might', 'must', 'can', 'prime', 'bank', 'primebank', 'i', 'me', 'my',
+        'we', 'you', 'your', 'they', 'their', 'this', 'that', 'these', 'those'
+    }
+    
+    # Extract words
+    words = re.findall(r'\b[a-z]+\b', all_text)
+    words = [word for word in words if word not in stop_words and len(word) > 3]
+    
+    # Count frequency
+    word_freq = Counter(words).most_common(top_n)
+    
+    if not word_freq:
+        return None
+    
+    # Create dataframe
+    freq_df = pd.DataFrame(word_freq, columns=['Word', 'Frequency'])
+    
+    # Create bar chart
+    fig = px.bar(
+        freq_df,
+        x='Frequency',
+        y='Word',
+        orientation='h',
+        title=f'Top {top_n} Words in Prime Bank Posts',
+        color='Frequency',
+        color_continuous_scale='Blues'
+    )
+    
+    fig.update_layout(
+        yaxis={'categoryorder': 'total ascending'},
+        showlegend=False
+    )
+    
+    return fig
+
+def create_sentiment_by_category(df):
+    """Create stacked bar chart of sentiment by category"""
+    # Filter for Prime Bank mentions
+    prime_df = df[df['prime_mentions'] > 0]
+    
+    if len(prime_df) == 0:
+        return None
+    
+    # Create crosstab
+    sentiment_category = pd.crosstab(
+        prime_df['category'],
+        prime_df['sentiment'],
+        normalize='index'
+    ) * 100
+    
+    # Create stacked bar chart
+    fig = go.Figure()
+    
+    sentiments = ['Positive', 'Negative', 'Neutral']
+    colors = {'Positive': '#2ecc71', 'Negative': '#e74c3c', 'Neutral': '#95a5a6'}
+    
+    for sentiment in sentiments:
+        if sentiment in sentiment_category.columns:
+            fig.add_trace(go.Bar(
+                name=sentiment,
+                x=sentiment_category.index,
+                y=sentiment_category[sentiment],
+                marker_color=colors.get(sentiment, '#95a5a6'),
+                hovertemplate='%{x}<br>%{y:.1f}%<extra></extra>'
+            ))
+    
+    fig.update_layout(
+        barmode='stack',
+        title='Sentiment Distribution by Post Category',
+        xaxis_title='Category',
+        yaxis_title='Percentage',
+        yaxis=dict(tickformat='.0f', ticksuffix='%'),
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
+    )
+    
+    return fig
+
+def create_priority_matrix(df):
+    """Create scatter plot showing priority posts"""
+    # Filter for Prime Bank mentions
+    prime_df = df[df['prime_mentions'] > 0].copy()
+    
+    if len(prime_df) == 0:
+        return None
+    
+    # Calculate urgency score (based on negative sentiment + complaints)
+    prime_df['urgency'] = 0
+    prime_df.loc[prime_df['sentiment'] == 'Negative', 'urgency'] += 2
+    prime_df.loc[prime_df['category'] == 'Complaint', 'urgency'] += 2
+    prime_df.loc[prime_df['emotion'].isin(['Frustration', 'Anxiety']), 'urgency'] += 1
+    
+    # Create scatter plot
+    fig = px.scatter(
+        prime_df,
+        x='viral_score',
+        y='urgency',
+        size='prime_mentions',
+        color='sentiment',
+        hover_data=['text', 'emotion', 'category'],
+        title='Priority Matrix: Viral Score vs Urgency',
+        color_discrete_map={
+            'Positive': '#2ecc71',
+            'Negative': '#e74c3c',
+            'Neutral': '#95a5a6'
+        }
+    )
+    
+    # Add quadrant lines
+    fig.add_hline(y=2.5, line_dash="dash", line_color="gray", opacity=0.5)
+    fig.add_vline(x=prime_df['viral_score'].median(), line_dash="dash", line_color="gray", opacity=0.5)
+    
+    # Add quadrant labels
+    fig.add_annotation(x=0.95, y=0.95, text="High Priority", xref="paper", yref="paper", showarrow=False)
+    fig.add_annotation(x=0.05, y=0.95, text="Monitor", xref="paper", yref="paper", showarrow=False)
+    
+    fig.update_layout(
+        xaxis_title="Viral Score (Reach)",
+        yaxis_title="Urgency Score",
+        showlegend=True
+    )
+    
+    return fig

test.py

@@ -0,0 +1,34 @@
+# test.py - Test if all packages are installed correctly
+import streamlit as st
+
+st.write("Testing if Streamlit works!")
+
+try:
+    import pandas as pd
+    st.success("✅ Pandas imported successfully")
+except:
+    st.error("❌ Pandas import failed")
+
+try:
+    import plotly
+    st.success("✅ Plotly imported successfully")
+except:
+    st.error("❌ Plotly import failed")
+
+try:
+    from textblob import TextBlob
+    st.success("✅ TextBlob imported successfully")
+except:
+    st.error("❌ TextBlob import failed")
+
+try:
+    import nltk
+    st.success("✅ NLTK imported successfully")
+except:
+    st.error("❌ NLTK import failed")
+
+try:
+    import openai
+    st.success("✅ OpenAI imported successfully")
+except:
+    st.error("❌ OpenAI import failed")