Memecoin Community Strength Indicator: Ollama Social Media Engagement Metrics

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull required models
ollama pull llama2:7b
ollama pull codellama:7b

# Verify installation
ollama list

# requirements.txt
ollama==0.1.9
tweepy==4.14.0
praw==7.7.1
pandas==2.0.3
numpy==1.24.3
matplotlib==3.7.2
seaborn==0.12.2
textblob==0.17.1

pip install -r requirements.txt

import ollama
import tweepy
import praw
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import json
import re

class MemecoinCommunityAnalyzer:
    def __init__(self, twitter_keys, reddit_keys):
        # Initialize social media APIs
        self.twitter_api = tweepy.Client(
            bearer_token=twitter_keys['bearer_token'],
            consumer_key=twitter_keys['consumer_key'],
            consumer_secret=twitter_keys['consumer_secret'],
            access_token=twitter_keys['access_token'],
            access_token_secret=twitter_keys['access_token_secret']
        )
        
        self.reddit = praw.Reddit(
            client_id=reddit_keys['client_id'],
            client_secret=reddit_keys['client_secret'],
            user_agent=reddit_keys['user_agent']
        )
        
        # Initialize Ollama client
        self.ollama_client = ollama.Client()
        
    def collect_twitter_data(self, coin_symbol, hours_back=24):
        """Collect Twitter mentions and engagement data"""
        end_time = datetime.now()
        start_time = end_time - timedelta(hours=hours_back)
        
        query = f"#{coin_symbol} OR ${coin_symbol} -is:retweet lang:en"
        
        tweets = tweepy.Paginator(
            self.twitter_api.search_recent_tweets,
            query=query,
            start_time=start_time,
            end_time=end_time,
            tweet_fields=['created_at', 'public_metrics', 'author_id', 'context_annotations'],
            max_results=100
        ).flatten(limit=1000)
        
        tweet_data = []
        for tweet in tweets:
            metrics = tweet.public_metrics
            tweet_data.append({
                'id': tweet.id,
                'text': tweet.text,
                'created_at': tweet.created_at,
                'author_id': tweet.author_id,
                'retweet_count': metrics['retweet_count'],
                'like_count': metrics['like_count'],
                'reply_count': metrics['reply_count'],
                'quote_count': metrics['quote_count']
            })
        
        return pd.DataFrame(tweet_data)
    
    def collect_reddit_data(self, coin_symbol, hours_back=24):
        """Collect Reddit posts and comments"""
        subreddits = ['CryptoCurrency', 'SatoshiStreetBets', 'CryptoMoonShots']
        reddit_data = []
        
        for subreddit_name in subreddits:
            subreddit = self.reddit.subreddit(subreddit_name)
            
            # Search for posts mentioning the coin
            for submission in subreddit.search(coin_symbol, time_filter='day', limit=100):
                post_age = datetime.now() - datetime.fromtimestamp(submission.created_utc)
                
                if post_age.total_seconds() / 3600 <= hours_back:
                    reddit_data.append({
                        'id': submission.id,
                        'title': submission.title,
                        'text': submission.selftext,
                        'created_at': datetime.fromtimestamp(submission.created_utc),
                        'score': submission.score,
                        'num_comments': submission.num_comments,
                        'upvote_ratio': submission.upvote_ratio,
                        'subreddit': subreddit_name
                    })
        
        return pd.DataFrame(reddit_data)

def analyze_sentiment_batch(self, texts):
    """Analyze sentiment using Ollama's local models"""
    prompt_template = """
    Analyze the sentiment of this cryptocurrency-related text. 
    Consider market context, emotional language, and community sentiment indicators.
    
    Text: "{text}"
    
    Provide analysis in JSON format:
    {{
        "sentiment": "positive/negative/neutral",
        "confidence": 0.0-1.0,
        "key_emotions": ["emotion1", "emotion2"],
        "market_sentiment": "bullish/bearish/neutral",
        "community_signals": ["signal1", "signal2"]
    }}
    """
    
    results = []
    for text in texts:
        try:
            response = self.ollama_client.generate(
                model='llama2:7b',
                prompt=prompt_template.format(text=text[:500]),  # Limit text length
                options={'temperature': 0.3}
            )
            
            # Parse JSON response
            sentiment_data = json.loads(response['response'])
            results.append(sentiment_data)
            
        except Exception as e:
            print(f"Error analyzing text: {e}")
            results.append({
                "sentiment": "neutral",
                "confidence": 0.5,
                "key_emotions": [],
                "market_sentiment": "neutral",
                "community_signals": []
            })
    
    return results

def calculate_engagement_metrics(self, df, platform):
    """Calculate platform-specific engagement metrics"""
    if platform == 'twitter':
        df['engagement_rate'] = (
            df['like_count'] + df['retweet_count'] + df['reply_count'] + df['quote_count']
        ) / df['like_count'].max()  # Normalize by max likes
        
        df['virality_score'] = (
            df['retweet_count'] * 2 + df['quote_count'] * 3
        ) / (df['retweet_count'].max() + 1)
        
    elif platform == 'reddit':
        df['engagement_rate'] = (
            df['score'] + df['num_comments']
        ) / df['score'].max()
        
        df['virality_score'] = (
            df['score'] * df['upvote_ratio'] + df['num_comments'] * 2
        ) / (df['score'].max() + 1)
    
    return df

def calculate_community_strength(self, twitter_df, reddit_df):
    """Calculate overall community strength score"""
    
    # Weight factors for different metrics
    weights = {
        'sentiment_score': 0.25,
        'engagement_velocity': 0.20,
        'volume_trend': 0.15,
        'influencer_participation': 0.15,
        'community_retention': 0.15,
        'cross_platform_consistency': 0.10
    }
    
    metrics = {}
    
    # 1. Sentiment Score (0-100)
    twitter_sentiment = twitter_df['sentiment_confidence'].mean() * 100
    reddit_sentiment = reddit_df['sentiment_confidence'].mean() * 100
    metrics['sentiment_score'] = (twitter_sentiment + reddit_sentiment) / 2
    
    # 2. Engagement Velocity (posts per hour)
    twitter_velocity = len(twitter_df) / 24  # Posts per hour
    reddit_velocity = len(reddit_df) / 24
    metrics['engagement_velocity'] = min((twitter_velocity + reddit_velocity) * 10, 100)
    
    # 3. Volume Trend (comparing recent vs older posts)
    recent_cutoff = datetime.now() - timedelta(hours=6)
    twitter_recent = twitter_df[twitter_df['created_at'] > recent_cutoff]
    reddit_recent = reddit_df[reddit_df['created_at'] > recent_cutoff]
    
    recent_volume = len(twitter_recent) + len(reddit_recent)
    older_volume = len(twitter_df) + len(reddit_df) - recent_volume
    
    if older_volume > 0:
        volume_trend = (recent_volume / older_volume) * 50
    else:
        volume_trend = 100
    
    metrics['volume_trend'] = min(volume_trend, 100)
    
    # 4. Influencer Participation (high engagement posts)
    twitter_high_engagement = twitter_df[twitter_df['engagement_rate'] > 0.8]
    reddit_high_engagement = reddit_df[reddit_df['engagement_rate'] > 0.8]
    
    influencer_ratio = (len(twitter_high_engagement) + len(reddit_high_engagement)) / (len(twitter_df) + len(reddit_df))
    metrics['influencer_participation'] = min(influencer_ratio * 200, 100)
    
    # 5. Community Retention (consistent posting patterns)
    twitter_authors = twitter_df['author_id'].nunique()
    reddit_authors = reddit_df['author_id'].nunique() if 'author_id' in reddit_df.columns else len(reddit_df)
    
    total_posts = len(twitter_df) + len(reddit_df)
    total_authors = twitter_authors + reddit_authors
    
    if total_authors > 0:
        retention_score = (total_posts / total_authors) * 20
    else:
        retention_score = 0
    
    metrics['community_retention'] = min(retention_score, 100)
    
    # 6. Cross-platform Consistency
    twitter_avg_sentiment = twitter_df['sentiment_confidence'].mean()
    reddit_avg_sentiment = reddit_df['sentiment_confidence'].mean()
    
    sentiment_consistency = 100 - abs(twitter_avg_sentiment - reddit_avg_sentiment) * 100
    metrics['cross_platform_consistency'] = max(sentiment_consistency, 0)
    
    # Calculate weighted final score
    final_score = sum(metrics[key] * weights[key] for key in weights.keys())
    
    return {
        'community_strength_score': round(final_score, 2),
        'component_scores': metrics,
        'strength_level': self._categorize_strength(final_score)
    }

def _categorize_strength(self, score):
    """Categorize community strength level"""
    if score >= 80:
        return "Very Strong"
    elif score >= 60:
        return "Strong"
    elif score >= 40:
        return "Moderate"
    elif score >= 20:
        return "Weak"
    else:
        return "Very Weak"

import schedule
import time
import logging
from datetime import datetime

class CommunityMonitor:
    def __init__(self, analyzer, coins_to_monitor):
        self.analyzer = analyzer
        self.coins = coins_to_monitor
        self.historical_data = {}
        
        # Setup logging
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('community_monitor.log'),
                logging.StreamHandler()
            ]
        )
        
    def monitor_coin(self, symbol):
        """Monitor a single coin's community strength"""
        try:
            logging.info(f"Starting analysis for {symbol}")
            
            # Collect data
            twitter_data = self.analyzer.collect_twitter_data(symbol)
            reddit_data = self.analyzer.collect_reddit_data(symbol)
            
            if twitter_data.empty and reddit_data.empty:
                logging.warning(f"No data found for {symbol}")
                return
            
            # Analyze sentiment
            if not twitter_data.empty:
                twitter_sentiments = self.analyzer.analyze_sentiment_batch(
                    twitter_data['text'].tolist()
                )
                twitter_data['sentiment_confidence'] = [s['confidence'] for s in twitter_sentiments]
                twitter_data = self.analyzer.calculate_engagement_metrics(twitter_data, 'twitter')
            
            if not reddit_data.empty:
                reddit_texts = (reddit_data['title'] + ' ' + reddit_data['text']).tolist()
                reddit_sentiments = self.analyzer.analyze_sentiment_batch(reddit_texts)
                reddit_data['sentiment_confidence'] = [s['confidence'] for s in reddit_sentiments]
                reddit_data = self.analyzer.calculate_engagement_metrics(reddit_data, 'reddit')
            
            # Calculate community strength
            strength_data = self.analyzer.calculate_community_strength(twitter_data, reddit_data)
            
            # Store results
            timestamp = datetime.now()
            if symbol not in self.historical_data:
                self.historical_data[symbol] = []
            
            self.historical_data[symbol].append({
                'timestamp': timestamp,
                'strength_score': strength_data['community_strength_score'],
                'strength_level': strength_data['strength_level'],
                'component_scores': strength_data['component_scores'],
                'twitter_posts': len(twitter_data),
                'reddit_posts': len(reddit_data)
            })
            
            # Log results
            logging.info(f"{symbol} Community Strength: {strength_data['community_strength_score']:.2f} ({strength_data['strength_level']})")
            
            # Check for alerts
            self._check_alerts(symbol, strength_data)
            
        except Exception as e:
            logging.error(f"Error monitoring {symbol}: {e}")
    
    def _check_alerts(self, symbol, strength_data):
        """Check for significant changes in community strength"""
        if symbol not in self.historical_data or len(self.historical_data[symbol]) < 2:
            return
        
        current_score = strength_data['community_strength_score']
        previous_score = self.historical_data[symbol][-2]['strength_score']
        
        change = current_score - previous_score
        
        # Alert thresholds
        if change > 20:
            logging.warning(f"🚀 {symbol} community strength SURGE: +{change:.2f} points")
        elif change < -20:
            logging.warning(f"📉 {symbol} community strength DROP: {change:.2f} points")
    
    def start_monitoring(self):
        """Start the monitoring schedule"""
        logging.info("Starting community strength monitoring...")
        
        # Schedule monitoring every 30 minutes
        for coin in self.coins:
            schedule.every(30).minutes.do(self.monitor_coin, coin)
        
        # Initial run
        for coin in self.coins:
            self.monitor_coin(coin)
        
        # Keep running
        while True:
            schedule.run_pending()
            time.sleep(60)  # Check every minute

import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.animation import FuncAnimation

class CommunityDashboard:
    def __init__(self, monitor):
        self.monitor = monitor
        self.fig, self.axes = plt.subplots(2, 2, figsize=(15, 10))
        self.fig.suptitle('Memecoin Community Strength Dashboard', fontsize=16)
        
    def create_strength_chart(self, symbol):
        """Create community strength timeline chart"""
        if symbol not in self.monitor.historical_data:
            return
        
        data = self.monitor.historical_data[symbol]
        timestamps = [d['timestamp'] for d in data]
        scores = [d['strength_score'] for d in data]
        
        ax = self.axes[0, 0]
        ax.clear()
        ax.plot(timestamps, scores, marker='o', linewidth=2)
        ax.set_title(f'{symbol} Community Strength Over Time')
        ax.set_ylabel('Strength Score')
        ax.grid(True, alpha=0.3)
        
        # Color code by strength level
        for i, score in enumerate(scores):
            color = self._get_strength_color(score)
            ax.plot(timestamps[i], score, 'o', color=color, markersize=6)
    
    def create_component_breakdown(self, symbol):
        """Create component scores breakdown"""
        if symbol not in self.monitor.historical_data or not self.monitor.historical_data[symbol]:
            return
        
        latest_data = self.monitor.historical_data[symbol][-1]
        components = latest_data['component_scores']
        
        ax = self.axes[0, 1]
        ax.clear()
        
        labels = list(components.keys())
        values = list(components.values())
        
        bars = ax.bar(labels, values, color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD'])
        ax.set_title(f'{symbol} Component Scores')
        ax.set_ylabel('Score')
        plt.setp(ax.get_xticklabels(), rotation=45, ha='right')
        
        # Add value labels on bars
        for bar, value in zip(bars, values):
            height = bar.get_height()
            ax.text(bar.get_x() + bar.get_width()/2., height + 1,
                   f'{value:.1f}', ha='center', va='bottom')
    
    def create_engagement_comparison(self):
        """Create cross-coin engagement comparison"""
        ax = self.axes[1, 0]
        ax.clear()
        
        coin_scores = {}
        for symbol, data in self.monitor.historical_data.items():
            if data:
                coin_scores[symbol] = data[-1]['strength_score']
        
        if not coin_scores:
            return
        
        coins = list(coin_scores.keys())
        scores = list(coin_scores.values())
        colors = [self._get_strength_color(score) for score in scores]
        
        bars = ax.bar(coins, scores, color=colors)
        ax.set_title('Community Strength Comparison')
        ax.set_ylabel('Strength Score')
        
        # Add value labels
        for bar, score in zip(bars, scores):
            height = bar.get_height()
            ax.text(bar.get_x() + bar.get_width()/2., height + 1,
                   f'{score:.1f}', ha='center', va='bottom')
    
    def create_activity_heatmap(self):
        """Create posting activity heatmap"""
        ax = self.axes[1, 1]
        ax.clear()
        
        # Aggregate hourly activity data
        activity_data = {}
        for symbol, data in self.monitor.historical_data.items():
            hourly_counts = {}
            for entry in data:
                hour = entry['timestamp'].hour
                total_posts = entry['twitter_posts'] + entry['reddit_posts']
                hourly_counts[hour] = hourly_counts.get(hour, 0) + total_posts
            activity_data[symbol] = hourly_counts
        
        if not activity_data:
            return
        
        # Create heatmap data
        coins = list(activity_data.keys())
        hours = list(range(24))
        heatmap_data = []
        
        for coin in coins:
            row = [activity_data[coin].get(hour, 0) for hour in hours]
            heatmap_data.append(row)
        
        if heatmap_data:
            sns.heatmap(heatmap_data, xticklabels=hours, yticklabels=coins, 
                       annot=True, fmt='d', cmap='YlOrRd', ax=ax)
            ax.set_title('Posting Activity Heatmap (by Hour)')
            ax.set_xlabel('Hour of Day')
    
    def _get_strength_color(self, score):
        """Get color based on strength score"""
        if score >= 80:
            return '#22C55E'  # Green
        elif score >= 60:
            return '#84CC16'  # Light green
        elif score >= 40:
            return '#F59E0B'  # Orange
        elif score >= 20:
            return '#EF4444'  # Red
        else:
            return '#991B1B'  # Dark red
    
    def update_dashboard(self, symbol):
        """Update dashboard with latest data"""
        self.create_strength_chart(symbol)
        self.create_component_breakdown(symbol)
        self.create_engagement_comparison()
        self.create_activity_heatmap()
        
        plt.tight_layout()
        plt.draw()

def detect_influencer_impact(self, twitter_df, threshold_followers=10000):
    """Detect posts from high-influence accounts"""
    
    # Get user information for high-engagement posts
    high_engagement_posts = twitter_df[twitter_df['engagement_rate'] > 0.7]
    
    influencer_posts = []
    for _, post in high_engagement_posts.iterrows():
        try:
            user_info = self.twitter_api.get_user(id=post['author_id'])
            
            if user_info.data.public_metrics['followers_count'] > threshold_followers:
                influencer_posts.append({
                    'post_id': post['id'],
                    'author_id': post['author_id'],
                    'username': user_info.data.username,
                    'followers': user_info.data.public_metrics['followers_count'],
                    'engagement_rate': post['engagement_rate'],
                    'text': post['text']
                })
        except Exception as e:
            continue
    
    return pd.DataFrame(influencer_posts)

def analyze_narrative_shifts(self, texts, time_window_hours=6):
    """Detect changes in community narrative"""
    
    # Group texts by time windows
    current_time = datetime.now()
    time_windows = []
    
    for i in range(0, 24, time_window_hours):
        window_start = current_time - timedelta(hours=i + time_window_hours)
        window_end = current_time - timedelta(hours=i)
        time_windows.append((window_start, window_end))
    
    window_themes = []
    
    for window_start, window_end in time_windows:
        window_texts = [
            text for text, timestamp in texts 
            if window_start <= timestamp <= window_end
        ]
        
        if not window_texts:
            continue
        
        # Extract themes using Ollama
        theme_prompt = f"""
        Analyze these cryptocurrency community posts and identify the main themes and narratives:
        
        Posts: {' '.join(window_texts[:10])}  # Limit for API
        
        Return top 3 themes in JSON format:
        {{
            "themes": [
                {{"theme": "theme name", "sentiment": "positive/negative/neutral", "frequency": 0.0-1.0}},
                ...
            ]
        }}
        """
        
        try:
            response = self.ollama_client.generate(
                model='llama2:7b',
                prompt=theme_prompt,
                options={'temperature': 0.3}
            )
            
            themes = json.loads(response['response'])
            window_themes.append({
                'time_window': f"{window_start.strftime('%H:%M')}-{window_end.strftime('%H:%M')}",
                'themes': themes['themes']
            })
            
        except Exception as e:
            print(f"Error analyzing themes: {e}")
    
    return window_themes

def calculate_community_health(self, twitter_df, reddit_df):
    """Calculate comprehensive community health metrics"""
    
    health_metrics = {}
    
    # 1. Diversity Score (unique authors vs total posts)
    total_posts = len(twitter_df) + len(reddit_df)
    unique_authors = twitter_df['author_id'].nunique()
    
    if 'author_id' in reddit_df.columns:
        unique_authors += reddit_df['author_id'].nunique()
    
    diversity_score = (unique_authors / total_posts) * 100 if total_posts > 0 else 0
    health_metrics['diversity_score'] = min(diversity_score, 100)
    
    # 2. Engagement Quality (replies/comments vs likes/upvotes)
    twitter_quality = twitter_df['reply_count'].sum() / (twitter_df['like_count'].sum() + 1)
    reddit_quality = reddit_df['num_comments'].sum() / (reddit_df['score'].sum() + 1)
    
    engagement_quality = ((twitter_quality + reddit_quality) / 2) * 100
    health_metrics['engagement_quality'] = min(engagement_quality, 100)
    
    # 3. Sentiment Stability (low volatility in sentiment)
    twitter_sentiment_std = twitter_df['sentiment_confidence'].std()
    reddit_sentiment_std = reddit_df['sentiment_confidence'].std()
    
    avg_sentiment_std = (twitter_sentiment_std + reddit_sentiment_std) / 2
    sentiment_stability = max(0, 100 - (avg_sentiment_std * 100))
    health_metrics['sentiment_stability'] = sentiment_stability
    
    # 4. Growth Momentum (recent activity vs historical average)
    recent_cutoff = datetime.now() - timedelta(hours=6)
    recent_posts = len(twitter_df[twitter_df['created_at'] > recent_cutoff]) + \
                   len(reddit_df[reddit_df['created_at'] > recent_cutoff])
    
    total_hours = 24
    recent_hours = 6
    expected_recent = (recent_hours / total_hours) * total_posts
    
    if expected_recent > 0:
        growth_momentum = (recent_posts / expected_recent) * 100
    else:
        growth_momentum = 100
    
    health_metrics['growth_momentum'] = min(growth_momentum, 200)
    
    # 5. Content Authenticity (low bot-like behavior)
    # Simple heuristic: posts with similar text patterns
    all_texts = twitter_df['text'].tolist() + reddit_df['title'].tolist()
    unique_texts = set(all_texts)
    
    authenticity_score = (len(unique_texts) / len(all_texts)) * 100 if all_texts else 100
    health_metrics['authenticity_score'] = authenticity_score
    
    # Calculate overall health score
    weights = {
        'diversity_score': 0.25,
        'engagement_quality': 0.20,
        'sentiment_stability': 0.20,
        'growth_momentum': 0.20,
        'authenticity_score': 0.15
    }
    
    overall_health = sum(health_metrics[key] * weights[key] for key in weights.keys())
    
    return {
        'overall_health_score': round(overall_health, 2),
        'health_metrics': health_metrics,
        'health_level': self._categorize_health(overall_health)
    }

def _categorize_health(self, score):
    """Categorize community health level"""
    if score >= 85:
        return "Excellent"
    elif score >= 70:
        return "Good"
    elif score >= 55:
        return "Fair"
    elif score >= 40:
        return "Poor"
    else:
        return "Critical"

# main.py
import os
from memecoin_analyzer import MemecoinCommunityAnalyzer, CommunityMonitor, CommunityDashboard

def main():
    # API Keys (set as environment variables)
    twitter_keys = {
        'bearer_token': os.getenv('TWITTER_BEARER_TOKEN'),
        'consumer_key': os.getenv('TWITTER_CONSUMER_KEY'),
        'consumer_secret': os.getenv('TWITTER_CONSUMER_SECRET'),
        'access_token': os.getenv('TWITTER_ACCESS_TOKEN'),
        'access_token_secret': os.getenv('TWITTER_ACCESS_TOKEN_SECRET')
    }
    
    reddit_keys = {
        'client_id': os.getenv('REDDIT_CLIENT_ID'),
        'client_secret': os.getenv('REDDIT_CLIENT_SECRET'),
        'user_agent': 'MemecoinAnalyzer/1.0'
    }
    
    # Initialize analyzer
    analyzer = MemecoinCommunityAnalyzer(twitter_keys, reddit_keys)
    
    # Coins to monitor
    coins_to_monitor = ['DOGE', 'SHIB', 'PEPE', 'FLOKI']
    
    # Start monitoring
    monitor = CommunityMonitor(analyzer, coins_to_monitor)
    
    # Optional: Create dashboard
    dashboard = CommunityDashboard(monitor)
    
    # Run analysis
    print("Starting memecoin community analysis...")
    monitor.start_monitoring()

if __name__ == "__main__":
    main()

# quick_analysis.py
def quick_analysis(coin_symbol):
    """Perform quick community strength analysis for a single coin"""
    
    # Initialize analyzer with your API keys
    analyzer = MemecoinCommunityAnalyzer(twitter_keys, reddit_keys)
    
    print(f"Analyzing {coin_symbol} community strength...")
    
    # Collect data
    twitter_data = analyzer.collect_twitter_data(coin_symbol, hours_back=24)
    reddit_data = analyzer.collect_reddit_data(coin_symbol, hours_back=24)
    
    if twitter_data.empty and reddit_data.empty:
        print(f"No recent social media activity found for {coin_symbol}")
        return
    
    # Analyze sentiment
    print("Analyzing sentiment...")
    if not twitter_data.empty:
        twitter_texts = twitter_data['text'].tolist()
        twitter_sentiments = analyzer.analyze_sentiment_batch(twitter_texts)
        twitter_data['sentiment_confidence'] = [s['confidence'] for s in twitter_sentiments]
        twitter_data = analyzer.calculate_engagement_metrics(twitter_data, 'twitter')
    
    if not reddit_data.empty:
        reddit_texts = (reddit_data['title'] + ' ' + reddit_data['text']).tolist()
        reddit_sentiments = analyzer.analyze_sentiment_batch(reddit_texts)
        reddit_data['sentiment_confidence'] = [s['confidence'] for s in reddit_sentiments]
        reddit_data = analyzer.calculate_engagement_metrics(reddit_data, 'reddit')
    
    # Calculate community strength
    strength_results = analyzer.calculate_community_strength(twitter_data, reddit_data)
    health_results = analyzer.calculate_community_health(twitter_data, reddit_data)
    
    # Display results
    print(f"\n{'='*50}")
    print(f"COMMUNITY ANALYSIS RESULTS FOR {coin_symbol}")
    print(f"{'='*50}")
    
    print(f"Overall Community Strength: {strength_results['community_strength_score']:.2f}/100")
    print(f"Strength Level: {strength_results['strength_level']}")
    print(f"Community Health: {health_results['overall_health_score']:.2f}/100")
    print(f"Health Level: {health_results['health_level']}")
    
    print(f"\nComponent Breakdown:")
    for component, score in strength_results['component_scores'].items():
        print(f"  {component.replace('_', ' ').title()}: {score:.2f}")
    
    print(f"\nData Summary:")
    print(f"  Twitter Posts: {len(twitter_data)}")
    print(f"  Reddit Posts: {len(reddit_data)}")
    print(f"  Average Sentiment: {(twitter_data['sentiment_confidence'].mean() + reddit_data['sentiment_confidence'].mean()) / 2:.2f}")
    
    return strength_results, health_results

# Usage example
if __name__ == "__main__":
    coin = input("Enter coin symbol (e.g., DOGE): ").upper()
    quick_analysis(coin)

# alert_system.py
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import requests
import json

class AlertSystem:
    def __init__(self, email_config=None, discord_webhook=None, telegram_config=None):
        self.email_config = email_config
        self.discord_webhook = discord_webhook
        self.telegram_config = telegram_config
        
    def send_strength_alert(self, coin_symbol, current_score, previous_score, alert_type):
        """Send community strength change alert"""
        
        change = current_score - previous_score
        
        if alert_type == "surge":
            emoji = "🚀"
            color = 0x00FF00  # Green
            message = f"Community strength SURGE detected for {coin_symbol}!"
        elif alert_type == "drop":
            emoji = "📉"
            color = 0xFF0000  # Red
            message = f"Community strength DROP detected for {coin_symbol}!"
        else:
            emoji = "⚠️"
            color = 0xFFFF00  # Yellow
            message = f"Community strength change for {coin_symbol}"
        
        alert_data = {
            'symbol': coin_symbol,
            'current_score': current_score,
            'previous_score': previous_score,
            'change': change,
            'timestamp': datetime.now().isoformat(),
            'message': message,
            'emoji': emoji,
            'color': color
        }
        
        # Send to all configured channels
        if self.email_config:
            self._send_email_alert(alert_data)
        
        if self.discord_webhook:
            self._send_discord_alert(alert_data)
        
        if self.telegram_config:
            self._send_telegram_alert(alert_data)
    
    def _send_email_alert(self, alert_data):
        """Send email alert"""
        try:
            msg = MIMEMultipart()
            msg['From'] = self.email_config['sender']
            msg['To'] = self.email_config['recipient']
            msg['Subject'] = f"Memecoin Alert: {alert_data['symbol']} Community Strength Change"
            
            body = f"""
            {alert_data['message']}
            
            Symbol: {alert_data['symbol']}
            Current Score: {alert_data['current_score']:.2f}
            Previous Score: {alert_data['previous_score']:.2f}
            Change: {alert_data['change']:+.2f}
            
            Timestamp: {alert_data['timestamp']}
            
            This is an automated alert from your Memecoin Community Strength Monitor.
            """
            
            msg.attach(MIMEText(body, 'plain'))
            
            server = smtplib.SMTP(self.email_config['smtp_server'], self.email_config['smtp_port'])
            server.starttls()
            server.login(self.email_config['sender'], self.email_config['password'])
            server.sendmail(self.email_config['sender'], self.email_config['recipient'], msg.as_string())
            server.quit()
            
        except Exception as e:
            print(f"Error sending email alert: {e}")
    
    def _send_discord_alert(self, alert_data):
        """Send Discord webhook alert"""
        try:
            embed = {
                "title": f"{alert_data['emoji']} {alert_data['symbol']} Community Alert",
                "description": alert_data['message'],
                "color": alert_data['color'],
                "fields": [
                    {"name": "Current Score", "value": f"{alert_data['current_score']:.2f}", "inline": True},
                    {"name": "Previous Score", "value": f"{alert_data['previous_score']:.2f}", "inline": True},
                    {"name": "Change", "value": f"{alert_data['change']:+.2f}", "inline": True}
                ],
                "timestamp": alert_data['timestamp'],
                "footer": {"text": "Memecoin Community Monitor"}
            }
            
            payload = {"embeds": [embed]}
            
            response = requests.post(self.discord_webhook, json=payload)
            response.raise_for_status()
            
        except Exception as e:
            print(f"Error sending Discord alert: {e}")
    
    def _send_telegram_alert(self, alert_data):
        """Send Telegram alert"""
        try:
            message = f"""
{alert_data['emoji']} *{alert_data['symbol']} Community Alert*

{alert_data['message']}

Current Score: `{alert_data['current_score']:.2f}`
Previous Score: `{alert_data['previous_score']:.2f}`
Change: `{alert_data['change']:+.2f}`

_{alert_data['timestamp']}_
            """
            
            payload = {
                'chat_id': self.telegram_config['chat_id'],
                'text': message,
                'parse_mode': 'Markdown'
            }
            
            url = f"https://api.telegram.org/bot{self.telegram_config['bot_token']}/sendMessage"
            response = requests.post(url, json=payload)
            response.raise_for_status()
            
        except Exception as e:
            print(f"Error sending Telegram alert: {e}")

# cache_manager.py
import redis
import pickle
from datetime import datetime, timedelta
import hashlib

class CacheManager:
    def __init__(self, redis_host='localhost', redis_port=6379, redis_db=0):
        self.redis_client = redis.Redis(host=redis_host, port=redis_port, db=redis_db)
        self.default_expiry = 1800  # 30 minutes
    
    def get_cached_data(self, key):
        """Retrieve cached data"""
        try:
            cached_data = self.redis_client.get(key)
            if cached_data:
                return pickle.loads(cached_data)
        except Exception as e:
            print(f"Cache retrieval error: {e}")
        return None
    
    def cache_data(self, key, data, expiry=None):
        """Cache data with expiry"""
        try:
            expiry = expiry or self.default_expiry
            pickled_data = pickle.dumps(data)
            self.redis_client.setex(key, expiry, pickled_data)
        except Exception as e:
            print(f"Cache storage error: {e}")
    
    def generate_cache_key(self, coin_symbol, data_type, hours_back=24):
        """Generate consistent cache key"""
        key_string = f"{coin_symbol}:{data_type}:{hours_back}:{datetime.now().strftime('%Y-%m-%d-%H')}"
        return hashlib.md5(key_string.encode()).hexdigest()
    
    def invalidate_cache(self, pattern):
        """Invalidate cache entries matching pattern"""
        try:
            keys = self.redis_client.keys(pattern)
            if keys:
                self.redis_client.delete(*keys)
        except Exception as e:
            print(f"Cache invalidation error: {e}")

# Modified analyzer with caching
class CachedMemecoinAnalyzer(MemecoinCommunityAnalyzer):
    def __init__(self, twitter_keys, reddit_keys, cache_manager=None):
        super().__init__(twitter_keys, reddit_keys)
        self.cache = cache_manager or CacheManager()
    
    def collect_twitter_data(self, coin_symbol, hours_back=24):
        """Collect Twitter data with caching"""
        cache_key = self.cache.generate_cache_key(coin_symbol, 'twitter', hours_back)
        
        # Try cache first
        cached_data = self.cache.get_cached_data(cache_key)
        if cached_data is not None:
            return cached_data
        
        # Fetch fresh data
        data = super().collect_twitter_data(coin_symbol, hours_back)
        
        # Cache the result
        self.cache.cache_data(cache_key, data, expiry=900)  # 15 minutes
        
        return data
    
    def collect_reddit_data(self, coin_symbol, hours_back=24):
        """Collect Reddit data with caching"""
        cache_key = self.cache.generate_cache_key(coin_symbol, 'reddit', hours_back)
        
        cached_data = self.cache.get_cached_data(cache_key)
        if cached_data is not None:
            return cached_data
        
        data = super().collect_reddit_data(coin_symbol, hours_back)
        self.cache.cache_data(cache_key, data, expiry=900)
        
        return data

# batch_processor.py
import concurrent.futures
from threading import Lock
import time

class BatchProcessor:
    def __init__(self, analyzer, max_workers=5):
        self.analyzer = analyzer
        self.max_workers = max_workers
        self.results_lock = Lock()
        self.results = {}
    
    def process_coin_batch(self, coin_symbols, hours_back=24):
        """Process multiple coins in parallel"""
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            # Submit all tasks
            future_to_coin = {
                executor.submit(self._process_single_coin, coin, hours_back): coin 
                for coin in coin_symbols
            }
            
            # Collect results
            for future in concurrent.futures.as_completed(future_to_coin):
                coin = future_to_coin[future]
                try:
                    result = future.result()
                    with self.results_lock:
                        self.results[coin] = result
                except Exception as e:
                    print(f"Error processing {coin}: {e}")
                    with self.results_lock:
                        self.results[coin] = None
        
        return self.results
    
    def _process_single_coin(self, coin_symbol, hours_back):
        """Process a single coin's data"""
        try:
            # Add small delay to avoid rate limiting
            time.sleep(0.5)
            
            # Collect data
            twitter_data = self.analyzer.collect_twitter_data(coin_symbol, hours_back)
            reddit_data = self.analyzer.collect_reddit_data(coin_symbol, hours_back)
            
            if twitter_data.empty and reddit_data.empty:
                return {'error': 'No data found'}
            
            # Analyze sentiment
            if not twitter_data.empty:
                twitter_texts = twitter_data['text'].tolist()
                twitter_sentiments = self.analyzer.analyze_sentiment_batch(twitter_texts)
                twitter_data['sentiment_confidence'] = [s['confidence'] for s in twitter_sentiments]
                twitter_data = self.analyzer.calculate_engagement_metrics(twitter_data, 'twitter')
            
            if not reddit_data.empty:
                reddit_texts = (reddit_data['title'] + ' ' + reddit_data['text']).tolist()
                reddit_sentiments = self.analyzer.analyze_sentiment_batch(reddit_texts)
                reddit_data['sentiment_confidence'] = [s['confidence'] for s in reddit_sentiments]
                reddit_data = self.analyzer.calculate_engagement_metrics(reddit_data, 'reddit')
            
            # Calculate metrics
            strength_results = self.analyzer.calculate_community_strength(twitter_data, reddit_data)
            health_results = self.analyzer.calculate_community_health(twitter_data, reddit_data)
            
            return {
                'strength': strength_results,
                'health': health_results,
                'data_counts': {
                    'twitter_posts': len(twitter_data),
                    'reddit_posts': len(reddit_data)
                },
                'timestamp': datetime.now().isoformat()
            }
            
        except Exception as e:
            return {'error': str(e)}

# Usage example
def batch_analysis_example():
    """Example of batch processing multiple coins"""
    
    # Initialize components
    analyzer = CachedMemecoinAnalyzer(twitter_keys, reddit_keys)
    processor = BatchProcessor(analyzer, max_workers=3)
    
    # List of coins to analyze
    coins = ['DOGE', 'SHIB', 'PEPE', 'FLOKI', 'BONK']
    
    print("Starting batch analysis...")
    results = processor.process_coin_batch(coins)
    
    # Display results
    print("\nBatch Analysis Results:")
    print("=" * 60)
    
    for coin, result in results.items():
        if result and 'error' not in result:
            strength_score = result['strength']['community_strength_score']
            health_score = result['health']['overall_health_score']
            
            print(f"{coin:6} | Strength: {strength_score:5.1f} | Health: {health_score:5.1f} | "
                  f"Posts: {result['data_counts']['twitter_posts']} + {result['data_counts']['reddit_posts']}")
        else:
            error_msg = result.get('error', 'Unknown error') if result else 'No result'
            print(f"{coin:6} | Error: {error_msg}")
    
    return results

if __name__ == "__main__":
    batch_analysis_example()

# config.py
import os
from dataclasses import dataclass

@dataclass
class AnalyzerConfig:
    # API Configuration
    twitter_rate_limit: int = 100  # requests per 15 minutes
    reddit_rate_limit: int = 60    # requests per minute
    
    # Analysis Parameters
    sentiment_batch_size: int = 10
    data_collection_hours: int = 24
    cache_expiry_minutes: int = 15
    
    # Alert Thresholds
    strength_surge_threshold: float = 20.0
    strength_drop_threshold: float = -20.0
    health_critical_threshold: float = 30.0
    
    # Processing Settings
    max_worker_threads: int = 3
    ollama_temperature: float = 0.3
    ollama_model: str = 'llama2:7b'
    
    @classmethod
    def from_env(cls):
        """Load configuration from environment variables"""
        return cls(
            twitter_rate_limit=int(os.getenv('TWITTER_RATE_LIMIT', 100)),
            reddit_rate_limit=int(os.getenv('REDDIT_RATE_LIMIT', 60)),
            sentiment_batch_size=int(os.getenv('SENTIMENT_BATCH_SIZE', 10)),
            data_collection_hours=int(os.getenv('DATA_COLLECTION_HOURS', 24)),
            cache_expiry_minutes=int(os.getenv('CACHE_EXPIRY_MINUTES', 15)),
            strength_surge_threshold=float(os.getenv('STRENGTH_SURGE_THRESHOLD', 20.0)),
            strength_drop_threshold=float(os.getenv('STRENGTH_DROP_THRESHOLD', -20.0)),
            health_critical_threshold=float(os.getenv('HEALTH_CRITICAL_THRESHOLD', 30.0)),
            max_worker_threads=int(os.getenv('MAX_WORKER_THREADS', 3)),
            ollama_temperature=float(os.getenv('OLLAMA_TEMPERATURE', 0.3)),
            ollama_model=os.getenv('OLLAMA_MODEL', 'llama2:7b')
        )