DAO Governance Analysis with Ollama: Proposal Voting and Decision Tracking

# governance_analyzer.py
import requests
import json
from datetime import datetime
from typing import Dict, List, Optional
import ollama

class DAOGovernanceAnalyzer:
    def __init__(self, ollama_model: str = "llama3.2"):
        self.ollama_model = ollama_model
        self.governance_apis = {
            'compound': 'https://api.compound.finance/api/v2/governance',
            'uniswap': 'https://api.thegraph.com/subgraphs/name/uniswap/governance',
            'aave': 'https://api.thegraph.com/subgraphs/name/aave/governance-v2'
        }
        self.proposal_cache = {}
    
    def fetch_proposals(self, dao_name: str, limit: int = 100) -> List[Dict]:
        """
        Fetch governance proposals from DAO APIs
        Returns structured proposal data for analysis
        """
        if dao_name not in self.governance_apis:
            raise ValueError(f"Unsupported DAO: {dao_name}")
        
        # Example for Compound governance
        if dao_name == 'compound':
            response = requests.get(
                f"{self.governance_apis[dao_name]}/proposals",
                params={'limit': limit}
            )
            return self._process_compound_proposals(response.json())
        
        # Add other DAO implementations here
        return []
    
    def _process_compound_proposals(self, raw_data: Dict) -> List[Dict]:
        """Process Compound governance API response"""
        proposals = []
        
        for proposal in raw_data.get('proposals', []):
            processed = {
                'id': proposal.get('id'),
                'title': proposal.get('title'),
                'description': proposal.get('description'),
                'proposer': proposal.get('proposer'),
                'start_block': proposal.get('start_block'),
                'end_block': proposal.get('end_block'),
                'for_votes': int(proposal.get('for_votes', 0)),
                'against_votes': int(proposal.get('against_votes', 0)),
                'abstain_votes': int(proposal.get('abstain_votes', 0)),
                'state': proposal.get('state'),
                'created_at': proposal.get('created_at'),
                'executed_at': proposal.get('executed_at')
            }
            proposals.append(processed)
        
        return proposals

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

# Pull required models for governance analysis
ollama pull llama3.2:7b      # General analysis
ollama pull codellama:7b     # Code and technical proposals
ollama pull mistral:7b       # Financial and economic analysis

# Verify installation
ollama list

# config.py
import os
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class AnalysisConfig:
    """Configuration for governance analysis"""
    ollama_base_url: str = "http://localhost:11434"
    default_model: str = "llama3.2:7b"
    analysis_models: Dict[str, str] = None
    max_tokens: int = 2048
    temperature: float = 0.1
    batch_size: int = 10
    
    def __post_init__(self):
        if self.analysis_models is None:
            self.analysis_models = {
                'general': 'llama3.2:7b',
                'technical': 'codellama:7b',
                'financial': 'mistral:7b'
            }

# Initialize configuration
config = AnalysisConfig()

# proposal_analyzer.py
import ollama
from typing import Dict, List, Tuple
import json
import re

class ProposalContentAnalyzer:
    def __init__(self, config: AnalysisConfig):
        self.config = config
        self.client = ollama.Client(host=config.ollama_base_url)
        
    def analyze_proposal_content(self, proposal: Dict) -> Dict:
        """
        Analyze proposal content using Ollama
        Returns structured analysis with categories and insights
        """
        # Combine title and description for analysis
        content = f"Title: {proposal.get('title', '')}\n"
        content += f"Description: {proposal.get('description', '')}"
        
        # Create analysis prompt
        prompt = self._create_analysis_prompt(content)
        
        # Get analysis from Ollama
        response = self.client.chat(
            model=self.config.default_model,
            messages=[{"role": "user", "content": prompt}],
            options={
                "temperature": self.config.temperature,
                "num_predict": self.config.max_tokens
            }
        )
        
        return self._parse_analysis_response(response['message']['content'])
    
    def _create_analysis_prompt(self, content: str) -> str:
        """Create structured prompt for proposal analysis"""
        return f"""
        Analyze this DAO governance proposal and provide structured insights:

        {content}

        Please provide analysis in the following JSON format:
        {{
            "category": "protocol_upgrade|parameter_change|treasury|partnership|other",
            "complexity": "low|medium|high",
            "risk_level": "low|medium|high",
            "impact_scope": "local|protocol|ecosystem",
            "technical_requirements": ["requirement1", "requirement2"],
            "key_stakeholders": ["stakeholder1", "stakeholder2"],
            "potential_outcomes": {{
                "positive": ["outcome1", "outcome2"],
                "negative": ["risk1", "risk2"]
            }},
            "summary": "Brief summary of the proposal",
            "recommendation": "support|oppose|neutral"
        }}

        Focus on governance implications and technical feasibility.
        """
    
    def _parse_analysis_response(self, response: str) -> Dict:
        """Parse Ollama response into structured data"""
        try:
            # Extract JSON from response
            json_match = re.search(r'\{.*\}', response, re.DOTALL)
            if json_match:
                return json.loads(json_match.group())
        except json.JSONDecodeError:
            pass
        
        # Fallback to manual parsing if JSON fails
        return {
            "category": "other",
            "complexity": "medium",
            "risk_level": "medium",
            "impact_scope": "protocol",
            "technical_requirements": [],
            "key_stakeholders": [],
            "potential_outcomes": {"positive": [], "negative": []},
            "summary": "Analysis failed",
            "recommendation": "neutral"
        }
    
    def batch_analyze_proposals(self, proposals: List[Dict]) -> List[Dict]:
        """Analyze multiple proposals efficiently"""
        analyzed_proposals = []
        
        for proposal in proposals:
            analysis = self.analyze_proposal_content(proposal)
            
            # Combine original proposal with analysis
            enhanced_proposal = {
                **proposal,
                'analysis': analysis,
                'analyzed_at': datetime.now().isoformat()
            }
            
            analyzed_proposals.append(enhanced_proposal)
        
        return analyzed_proposals

# voting_analyzer.py
from collections import defaultdict
import numpy as np
from typing import Dict, List, Tuple

class VotingPatternAnalyzer:
    def __init__(self, config: AnalysisConfig):
        self.config = config
        self.client = ollama.Client(host=config.ollama_base_url)
        
    def analyze_voting_patterns(self, proposals: List[Dict]) -> Dict:
        """
        Analyze voting patterns across proposals
        Returns comprehensive voting behavior insights
        """
        # Calculate basic voting metrics
        voting_metrics = self._calculate_voting_metrics(proposals)
        
        # Analyze voter participation patterns
        participation_analysis = self._analyze_participation(proposals)
        
        # Identify voting trends
        trend_analysis = self._analyze_voting_trends(proposals)
        
        # Generate AI insights
        ai_insights = self._generate_voting_insights(
            voting_metrics, participation_analysis, trend_analysis
        )
        
        return {
            'metrics': voting_metrics,
            'participation': participation_analysis,
            'trends': trend_analysis,
            'insights': ai_insights,
            'analyzed_at': datetime.now().isoformat()
        }
    
    def _calculate_voting_metrics(self, proposals: List[Dict]) -> Dict:
        """Calculate basic voting statistics"""
        total_proposals = len(proposals)
        passed_proposals = sum(1 for p in proposals if p.get('state') == 'executed')
        
        # Vote distribution analysis
        total_for_votes = sum(p.get('for_votes', 0) for p in proposals)
        total_against_votes = sum(p.get('against_votes', 0) for p in proposals)
        total_abstain_votes = sum(p.get('abstain_votes', 0) for p in proposals)
        
        return {
            'total_proposals': total_proposals,
            'passed_proposals': passed_proposals,
            'passage_rate': passed_proposals / total_proposals if total_proposals > 0 else 0,
            'vote_distribution': {
                'for': total_for_votes,
                'against': total_against_votes,
                'abstain': total_abstain_votes
            },
            'average_participation': self._calculate_average_participation(proposals)
        }
    
    def _analyze_participation(self, proposals: List[Dict]) -> Dict:
        """Analyze voter participation patterns"""
        participation_rates = []
        
        for proposal in proposals:
            total_votes = (
                proposal.get('for_votes', 0) +
                proposal.get('against_votes', 0) +
                proposal.get('abstain_votes', 0)
            )
            participation_rates.append(total_votes)
        
        return {
            'average_participation': np.mean(participation_rates),
            'participation_std': np.std(participation_rates),
            'min_participation': min(participation_rates),
            'max_participation': max(participation_rates),
            'participation_trend': self._calculate_participation_trend(proposals)
        }
    
    def _analyze_voting_trends(self, proposals: List[Dict]) -> Dict:
        """Analyze voting trends over time"""
        # Sort proposals by creation date
        sorted_proposals = sorted(
            proposals, 
            key=lambda x: x.get('created_at', ''),
            reverse=True
        )
        
        # Calculate rolling averages
        window_size = 10
        trends = {
            'passage_rate_trend': [],
            'participation_trend': [],
            'controversy_trend': []
        }
        
        for i in range(len(sorted_proposals) - window_size + 1):
            window = sorted_proposals[i:i + window_size]
            
            # Passage rate trend
            passed = sum(1 for p in window if p.get('state') == 'executed')
            trends['passage_rate_trend'].append(passed / window_size)
            
            # Participation trend
            total_votes = sum(
                p.get('for_votes', 0) + p.get('against_votes', 0) + p.get('abstain_votes', 0)
                for p in window
            )
            trends['participation_trend'].append(total_votes / window_size)
            
            # Controversy trend (close votes)
            controversy_scores = []
            for p in window:
                for_votes = p.get('for_votes', 0)
                against_votes = p.get('against_votes', 0)
                total = for_votes + against_votes
                if total > 0:
                    controversy = 1 - abs(for_votes - against_votes) / total
                    controversy_scores.append(controversy)
            
            trends['controversy_trend'].append(
                np.mean(controversy_scores) if controversy_scores else 0
            )
        
        return trends
    
    def _generate_voting_insights(self, metrics: Dict, participation: Dict, trends: Dict) -> Dict:
        """Generate AI insights from voting data"""
        # Create insight prompt
        data_summary = f"""
        Voting Metrics:
        - Total Proposals: {metrics['total_proposals']}
        - Passage Rate: {metrics['passage_rate']:.2%}
        - Vote Distribution: For: {metrics['vote_distribution']['for']}, Against: {metrics['vote_distribution']['against']}, Abstain: {metrics['vote_distribution']['abstain']}
        
        Participation Analysis:
        - Average Participation: {participation['average_participation']:.0f}
        - Participation Standard Deviation: {participation['participation_std']:.0f}
        - Participation Range: {participation['min_participation']:.0f} - {participation['max_participation']:.0f}
        
        Trends:
        - Recent Passage Rate Trend: {trends['passage_rate_trend'][-5:] if trends['passage_rate_trend'] else 'No data'}
        - Recent Participation Trend: {trends['participation_trend'][-5:] if trends['participation_trend'] else 'No data'}
        """
        
        prompt = f"""
        Analyze this DAO governance voting data and provide insights:

        {data_summary}

        Please provide analysis in JSON format:
        {{
            "governance_health": "healthy|concerning|unhealthy",
            "participation_assessment": "high|medium|low",
            "key_observations": ["observation1", "observation2"],
            "potential_issues": ["issue1", "issue2"],
            "recommendations": ["recommendation1", "recommendation2"],
            "summary": "Brief summary of governance state"
        }}

        Focus on governance effectiveness and community engagement.
        """
        
        response = self.client.chat(
            model=self.config.default_model,
            messages=[{"role": "user", "content": prompt}],
            options={"temperature": 0.1}
        )
        
        return self._parse_analysis_response(response['message']['content'])

# decision_tracker.py
import sqlite3
from datetime import datetime, timedelta
from typing import Dict, List, Optional

class DecisionTracker:
    def __init__(self, db_path: str = "governance_decisions.db"):
        self.db_path = db_path
        self.init_database()
        
    def init_database(self):
        """Initialize decision tracking database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Create proposals table
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS proposals (
                id TEXT PRIMARY KEY,
                dao_name TEXT,
                title TEXT,
                description TEXT,
                proposer TEXT,
                created_at TEXT,
                voting_start TEXT,
                voting_end TEXT,
                state TEXT,
                for_votes INTEGER,
                against_votes INTEGER,
                abstain_votes INTEGER,
                execution_hash TEXT,
                analysis_data TEXT,
                updated_at TEXT
            )
        ''')
        
        # Create decision outcomes table
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS decision_outcomes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                proposal_id TEXT,
                outcome_type TEXT,
                implementation_status TEXT,
                impact_metrics TEXT,
                follow_up_required BOOLEAN,
                notes TEXT,
                recorded_at TEXT,
                FOREIGN KEY (proposal_id) REFERENCES proposals (id)
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def track_proposal_decision(self, proposal: Dict, outcome_data: Dict):
        """Track a proposal decision and its outcomes"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Insert or update proposal
        cursor.execute('''
            INSERT OR REPLACE INTO proposals (
                id, dao_name, title, description, proposer, created_at,
                voting_start, voting_end, state, for_votes, against_votes,
                abstain_votes, execution_hash, analysis_data, updated_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ''', (
            proposal['id'],
            proposal.get('dao_name', ''),
            proposal.get('title', ''),
            proposal.get('description', ''),
            proposal.get('proposer', ''),
            proposal.get('created_at', ''),
            proposal.get('voting_start', ''),
            proposal.get('voting_end', ''),
            proposal.get('state', ''),
            proposal.get('for_votes', 0),
            proposal.get('against_votes', 0),
            proposal.get('abstain_votes', 0),
            proposal.get('execution_hash', ''),
            json.dumps(proposal.get('analysis', {})),
            datetime.now().isoformat()
        ))
        
        # Record decision outcome
        cursor.execute('''
            INSERT INTO decision_outcomes (
                proposal_id, outcome_type, implementation_status,
                impact_metrics, follow_up_required, notes, recorded_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?)
        ''', (
            proposal['id'],
            outcome_data.get('outcome_type', 'unknown'),
            outcome_data.get('implementation_status', 'pending'),
            json.dumps(outcome_data.get('impact_metrics', {})),
            outcome_data.get('follow_up_required', False),
            outcome_data.get('notes', ''),
            datetime.now().isoformat()
        ))
        
        conn.commit()
        conn.close()
    
    def get_implementation_status(self, proposal_id: str) -> Optional[Dict]:
        """Get current implementation status for a proposal"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT p.*, do.outcome_type, do.implementation_status,
                   do.impact_metrics, do.follow_up_required, do.notes
            FROM proposals p
            LEFT JOIN decision_outcomes do ON p.id = do.proposal_id
            WHERE p.id = ?
            ORDER BY do.recorded_at DESC
            LIMIT 1
        ''', (proposal_id,))
        
        result = cursor.fetchone()
        conn.close()
        
        if result:
            return {
                'proposal_id': result[0],
                'title': result[2],
                'state': result[8],
                'outcome_type': result[15],
                'implementation_status': result[16],
                'impact_metrics': json.loads(result[17] or '{}'),
                'follow_up_required': result[18],
                'notes': result[19]
            }
        
        return None
    
    def generate_governance_report(self, dao_name: str, days: int = 30) -> Dict:
        """Generate comprehensive governance report"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Get recent proposals
        cutoff_date = (datetime.now() - timedelta(days=days)).isoformat()
        
        cursor.execute('''
            SELECT p.*, do.outcome_type, do.implementation_status
            FROM proposals p
            LEFT JOIN decision_outcomes do ON p.id = do.proposal_id
            WHERE p.dao_name = ? AND p.created_at >= ?
            ORDER BY p.created_at DESC
        ''', (dao_name, cutoff_date))
        
        proposals = cursor.fetchall()
        conn.close()
        
        # Calculate report metrics
        total_proposals = len(proposals)
        executed_proposals = sum(1 for p in proposals if p[8] == 'executed')
        
        return {
            'dao_name': dao_name,
            'report_period': f"{days} days",
            'total_proposals': total_proposals,
            'executed_proposals': executed_proposals,
            'execution_rate': executed_proposals / total_proposals if total_proposals > 0 else 0,
            'proposals': [
                {
                    'id': p[0],
                    'title': p[2],
                    'state': p[8],
                    'for_votes': p[9],
                    'against_votes': p[10],
                    'outcome_type': p[15],
                    'implementation_status': p[16]
                }
                for p in proposals
            ],
            'generated_at': datetime.now().isoformat()
        }

# governance_monitor.py
import asyncio
import aiohttp
from datetime import datetime, timedelta
import logging
from typing import Dict, List, Callable

class GovernanceMonitor:
    def __init__(self, analyzer: DAOGovernanceAnalyzer, 
                 tracker: DecisionTracker, 
                 config: AnalysisConfig):
        self.analyzer = analyzer
        self.tracker = tracker
        self.config = config
        self.monitoring_active = False
        self.alert_handlers: List[Callable] = []
        
        # Setup logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def add_alert_handler(self, handler: Callable):
        """Add alert handler for governance events"""
        self.alert_handlers.append(handler)
    
    async def start_monitoring(self, dao_names: List[str], 
                              check_interval: int = 300):
        """Start continuous governance monitoring"""
        self.monitoring_active = True
        self.logger.info(f"Starting governance monitoring for {dao_names}")
        
        while self.monitoring_active:
            try:
                for dao_name in dao_names:
                    await self._check_dao_updates(dao_name)
                
                await asyncio.sleep(check_interval)
                
            except Exception as e:
                self.logger.error(f"Error in monitoring loop: {e}")
                await asyncio.sleep(60)  # Wait before retrying
    
    async def _check_dao_updates(self, dao_name: str):
        """Check for new governance updates in a DAO"""
        try:
            # Fetch latest proposals
            recent_proposals = self.analyzer.fetch_proposals(dao_name, limit=10)
            
            # Check for new or updated proposals
            for proposal in recent_proposals:
                await self._process_proposal_update(dao_name, proposal)
                
        except Exception as e:
            self.logger.error(f"Error checking {dao_name} updates: {e}")
    
    async def _process_proposal_update(self, dao_name: str, proposal: Dict):
        """Process individual proposal updates"""
        proposal_id = proposal['id']
        
        # Check if proposal is new or updated
        existing_status = self.tracker.get_implementation_status(proposal_id)
        
        if not existing_status:
            # New proposal - perform full analysis
            await self._analyze_new_proposal(dao_name, proposal)
        else:
            # Check for state changes
            if existing_status['state'] != proposal.get('state'):
                await self._handle_state_change(dao_name, proposal, existing_status)
    
    async def _analyze_new_proposal(self, dao_name: str, proposal: Dict):
        """Analyze new proposal and trigger alerts"""
        self.logger.info(f"New proposal detected: {proposal['id']}")
        
        # Add DAO name to proposal
        proposal['dao_name'] = dao_name
        
        # Perform content analysis
        content_analyzer = ProposalContentAnalyzer(self.config)
        analysis = content_analyzer.analyze_proposal_content(proposal)
        proposal['analysis'] = analysis
        
        # Track the proposal
        outcome_data = {
            'outcome_type': 'new_proposal',
            'implementation_status': 'voting',
            'impact_metrics': {},
            'follow_up_required': True,
            'notes': f'New proposal submitted by {proposal.get("proposer", "unknown")}'
        }
        
        self.tracker.track_proposal_decision(proposal, outcome_data)
        
        # Trigger alerts for high-impact proposals
        await self._trigger_proposal_alerts(proposal)
    
    async def _handle_state_change(self, dao_name: str, proposal: Dict, 
                                  existing_status: Dict):
        """Handle proposal state changes"""
        old_state = existing_status['state']
        new_state = proposal.get('state')
        
        self.logger.info(f"State change for {proposal['id']}: {old_state} -> {new_state}")
        
        # Update tracking
        outcome_data = {
            'outcome_type': 'state_change',
            'implementation_status': new_state,
            'impact_metrics': {
                'previous_state': old_state,
                'new_state': new_state,
                'final_vote_count': {
                    'for': proposal.get('for_votes', 0),
                    'against': proposal.get('against_votes', 0),
                    'abstain': proposal.get('abstain_votes', 0)
                }
            },
            'follow_up_required': new_state == 'executed',
            'notes': f'State changed from {old_state} to {new_state}'
        }
        
        proposal['dao_name'] = dao_name
        self.tracker.track_proposal_decision(proposal, outcome_data)
        
        # Trigger state change alerts
        await self._trigger_state_change_alerts(proposal, old_state, new_state)
    
    async def _trigger_proposal_alerts(self, proposal: Dict):
        """Trigger alerts for new proposals"""
        analysis = proposal.get('analysis', {})
        
        # Alert conditions
        should_alert = (
            analysis.get('risk_level') == 'high' or
            analysis.get('impact_scope') == 'ecosystem' or
            analysis.get('complexity') == 'high'
        )
        
        if should_alert:
            alert_data = {
                'type': 'new_proposal',
                'dao_name': proposal['dao_name'],
                'proposal_id': proposal['id'],
                'title': proposal.get('title', ''),
                'risk_level': analysis.get('risk_level', 'unknown'),
                'impact_scope': analysis.get('impact_scope', 'unknown'),
                'recommendation': analysis.get('recommendation', 'neutral'),
                'summary': analysis.get('summary', ''),
                'timestamp': datetime.now().isoformat()
            }
            
            for handler in self.alert_handlers:
                try:
                    await handler(alert_data)
                except Exception as e:
                    self.logger.error(f"Error in alert handler: {e}")
    
    async def _trigger_state_change_alerts(self, proposal: Dict, 
                                         old_state: str, new_state: str):
        """Trigger alerts for state changes"""
        # Alert for executed proposals
        if new_state == 'executed':
            alert_data = {
                'type': 'proposal_executed',
                'dao_name': proposal['dao_name'],
                'proposal_id': proposal['id'],
                'title': proposal.get('title', ''),
                'old_state': old_state,
                'new_state': new_state,
                'execution_votes': {
                    'for': proposal.get('for_votes', 0),
                    'against': proposal.get('against_votes', 0)
                },
                'timestamp': datetime.now().isoformat()
            }
            
            for handler in self.alert_handlers:
                try:
                    await handler(alert_data)
                except Exception as e:
                    self.logger.error(f"Error in alert handler: {e}")
    
    def stop_monitoring(self):
        """Stop the monitoring process"""
        self.monitoring_active = False
        self.logger.info("Governance monitoring stopped")

# Example alert handler
async def discord_alert_handler(alert_data: Dict):
    """Example Discord webhook alert handler"""
    webhook_url = "YOUR_DISCORD_WEBHOOK_URL"
    
    if alert_data['type'] == 'new_proposal':
        message = f"🚨 **New High-Impact Proposal**\n"
        message += f"**DAO:** {alert_data['dao_name']}\n"
        message += f"**Title:** {alert_data['title']}\n"
        message += f"**Risk Level:** {alert_data['risk_level']}\n"
        message += f"**Recommendation:** {alert_data['recommendation']}\n"
        message += f"**Summary:** {alert_data['summary']}"
    
    elif alert_data['type'] == 'proposal_executed':
        message = f"✅ **Proposal Executed**\n"
        message += f"**DAO:** {alert_data['dao_name']}\n"
        message += f"**Title:** {alert_data['title']}\n"
        message += f"**For Votes:** {alert_data['execution_votes']['for']}\n"
        message += f"**Against Votes:** {alert_data['execution_votes']['against']}"
    
    async with aiohttp.ClientSession() as session:
        payload = {"content": message}
        async with session.post(webhook_url, json=payload) as response:
            if response.status != 204:
                print(f"Failed to send Discord alert: {response.status}")

# analytics_dashboard.py
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import numpy as np

class GovernanceAnalyticsDashboard:
    def __init__(self, tracker: DecisionTracker, analyzer: DAOGovernanceAnalyzer):
        self.tracker = tracker
        self.analyzer = analyzer
        
    def generate_governance_dashboard(self, dao_name: str, 
                                    time_period: int = 90) -> Dict:
        """Generate comprehensive governance analytics dashboard"""
        # Get historical data
        report_data = self.tracker.generate_governance_report(dao_name, time_period)
        proposals = report_data['proposals']
        
        # Calculate advanced metrics
        analytics = {
            'basic_metrics': self._calculate_basic_metrics(proposals),
            'participation_analysis': self._analyze_participation_trends(proposals),
            'voting_behavior': self._analyze_voting_behavior(proposals),
            'proposal_categories': self._analyze_proposal_categories(proposals),
            'governance_health': self._assess_governance_health(proposals),
            'predictive_insights': self._generate_predictive_insights(proposals)
        }
        
        return analytics
    
    def _calculate_basic_metrics(self, proposals: List[Dict]) -> Dict:
        """Calculate fundamental governance metrics"""
        if not proposals:
            return {}
        
        total_proposals = len(proposals)
        executed_count = sum(1 for p in proposals if p['state'] == 'executed')
        defeated_count = sum(1 for p in proposals if p['state'] == 'defeated')
        
        # Vote totals
        total_for_votes = sum(p['for_votes'] for p in proposals)
        total_against_votes = sum(p['against_votes'] for p in proposals)
        
        return {
            'total_proposals': total_proposals,
            'executed_proposals': executed_count,
            'defeated_proposals': defeated_count,
            'execution_rate': executed_count / total_proposals,
            'defeat_rate': defeated_count / total_proposals,
            'total_participation': total_for_votes + total_against_votes,
            'support_ratio': total_for_votes / (total_for_votes + total_against_votes) if (total_for_votes + total_against_votes) > 0 else 0
        }
    
    def _analyze_participation_trends(self, proposals: List[Dict]) -> Dict:
        """Analyze voter participation trends over time"""
        if not proposals:
            return {}
        
        # Calculate participation for each proposal
        participation_data = []
        for proposal in proposals:
            total_votes = proposal['for_votes'] + proposal['against_votes']
            participation_data.append({
                'proposal_id': proposal['id'],
                'total_votes': total_votes,
                'for_votes': proposal['for_votes'],
                'against_votes': proposal['against_votes']
            })
        
        # Calculate trends
        participations = [p['total_votes'] for p in participation_data]
        
        return {
            'average_participation': np.mean(participations),
            'participation_volatility': np.std(participations),
            'min_participation': min(participations),
            'max_participation': max(participations),
            'participation_trend': self._calculate_trend(participations),
            'engagement_score': self._calculate_engagement_score(participation_data)
        }
    
    def _analyze_voting_behavior(self, proposals: List[Dict]) -> Dict:
        """Analyze voting behavior patterns"""
        if not proposals:
            return {}
        
        # Calculate voting patterns
        unanimous_support = sum(1 for p in proposals if p['against_votes'] == 0 and p['for_votes'] > 0)
        unanimous_opposition = sum(1 for p in proposals if p['for_votes'] == 0 and p['against_votes'] > 0)
        contested_votes = sum(1 for p in proposals if p['for_votes'] > 0 and p['against_votes'] > 0)
        
        # Calculate controversy scores
        controversy_scores = []
        for proposal in proposals:
            total_votes = proposal['for_votes'] + proposal['against_votes']
            if total_votes > 0:
                # Higher score = more controversial (closer to 50/50)
                controversy = 1 - abs(proposal['for_votes'] - proposal['against_votes']) / total_votes
                controversy_scores.append(controversy)
        
        return {
            'unanimous_support_count': unanimous_support,
            'unanimous_opposition_count': unanimous_opposition,
            'contested_votes_count': contested_votes,
            'average_controversy': np.mean(controversy_scores) if controversy_scores else 0,
            'highly_controversial_proposals': sum(1 for score in controversy_scores if score > 0.8),
            'consensus_proposals': sum(1 for score in controversy_scores if score < 0.2)
        }
    
    def _analyze_proposal_categories(self, proposals: List[Dict]) -> Dict:
        """Analyze proposal categories and their success rates"""
        # This would typically use the analysis data from earlier
        # For now, we'll create a simplified version
        
        category_stats = {}
        implementation_categories = ['protocol_upgrade', 'parameter_change', 'treasury', 'partnership']
        
        for category in implementation_categories:
            # In a real implementation, you'd filter by actual categories
            category_proposals = [p for p in proposals if hash(p['id']) % 4 == implementation_categories.index(category)]
            
            if category_proposals:
                executed = sum(1 for p in category_proposals if p['state'] == 'executed')
                category_stats[category] = {
                    'total': len(category_proposals),
                    'executed': executed,
                    'success_rate': executed / len(category_proposals),
                    'average_for_votes': np.mean([p['for_votes'] for p in category_proposals]),
                    'average_against_votes': np.mean([p['against_votes'] for p in category_proposals])
                }
        
        return category_stats
    
    def _assess_governance_health(self, proposals: List[Dict]) -> Dict:
        """Assess overall governance health"""
        if not proposals:
            return {'health_score': 0, 'status': 'insufficient_data'}
        
        # Calculate health indicators
        execution_rate = sum(1 for p in proposals if p['state'] == 'executed') / len(proposals)
        avg_participation = np.mean([p['for_votes'] + p['against_votes'] for p in proposals])
        
        # Normalize participation (this would be calibrated based on token distribution)
        participation_score = min(avg_participation / 1000000, 1.0)  # Assuming 1M is high participation
        
        # Calculate diversity score (how evenly distributed votes are)
        vote_distributions = []
        for proposal in proposals:
            total = proposal['for_votes'] + proposal['against_votes']
            if total > 0:
                for_ratio = proposal['for_votes'] / total
                # Diversity is higher when votes are more evenly distributed
                diversity = 1 - abs(for_ratio - 0.5) * 2
                vote_distributions.append(diversity)
        
        diversity_score = np.mean(vote_distributions) if vote_distributions else 0
        
        # Combined health score
        health_score = (execution_rate * 0.4 + participation_score * 0.4 + diversity_score * 0.2)
        
        # Determine status
        if health_score >= 0.8:
            status = 'excellent'
        elif health_score >= 0.6:
            status = 'good'
        elif health_score >= 0.4:
            status = 'fair'
        else:
            status = 'poor'
        
        return {
            'health_score': health_score,
            'status': status,
            'execution_rate': execution_rate,
            'participation_score': participation_score,
            'diversity_score': diversity_score,
            'recommendations': self._generate_health_recommendations(health_score, execution_rate, participation_score)
        }
    
    def _generate_predictive_insights(self, proposals: List[Dict]) -> Dict:
        """Generate predictive insights using historical data"""
        if len(proposals) < 5:
            return {'prediction_available': False}
        
        # Simple trend analysis
        recent_proposals = sorted(proposals, key=lambda x: x['id'])[-10:]
        older_proposals = sorted(proposals, key=lambda x: x['id'])[:-10] if len(proposals) > 10 else []
        
        recent_execution_rate = sum(1 for p in recent_proposals if p['state'] == 'executed') / len(recent_proposals)
        recent_participation = np.mean([p['for_votes'] + p['against_votes'] for p in recent_proposals])
        
        if older_proposals:
            older_execution_rate = sum(1 for p in older_proposals if p['state'] == 'executed') / len(older_proposals)
            older_participation = np.mean([p['for_votes'] + p['against_votes'] for p in older_proposals])
            
            execution_trend = 'increasing' if recent_execution_rate > older_execution_rate else 'decreasing'
            participation_trend = 'increasing' if recent_participation > older_participation else 'decreasing'
        else:
            execution_trend = 'stable'
            participation_trend = 'stable'
        
        return {
            'prediction_available': True,
            'execution_rate_trend': execution_trend,
            'participation_trend': participation_trend,
            'recent_execution_rate': recent_execution_rate,
            'recent_participation': recent_participation,
            'forecast_confidence': 'low' if len(proposals) < 20 else 'medium'
        }
    
    def _calculate_trend(self, values: List[float]) -> str:
        """Calculate trend direction from time series data"""
        if len(values) < 2:
            return 'stable'
        
        # Simple linear trend
        x = np.arange(len(values))
        slope = np.polyfit(x, values, 1)[0]
        
        if slope > 0.1:
            return 'increasing'
        elif slope < -0.1:
            return 'decreasing'
        else:
            return 'stable'
    
    def _calculate_engagement_score(self, participation_data: List[Dict]) -> float:
        """Calculate overall engagement score"""
        if not participation_data:
            return 0
        
        # Consider both participation levels and consistency
        participations = [p['total_votes'] for p in participation_data]
        avg_participation = np.mean(participations)
        consistency = 1 - (np.std(participations) / avg_participation) if avg_participation > 0 else 0
        
        # Normalize and combine
        normalized_participation = min(avg_participation / 500000, 1.0)  # Assuming 500k is good participation
        
        return (normalized_participation * 0.7 + consistency * 0.3)
    
    def _generate_health_recommendations(self, health_score: float, 
                                       execution_rate: float, 
                                       participation_score: float) -> List[str]:
        """Generate recommendations based on health metrics"""
        recommendations = []
        
        if execution_rate < 0.3:
            recommendations.append("Consider reviewing proposal quality and community alignment")
        
        if participation_score < 0.4:
            recommendations.append("Implement strategies to increase voter engagement")
        
        if health_score < 0.5:
            recommendations.append("Review governance parameters and incentive structures")
        
        if not recommendations:
            recommendations.append("Maintain current governance practices")
        
        return recommendations

# Usage example and main execution
async def main():
    """Main execution function demonstrating complete governance analysis"""
    
    # Initialize components
    config = AnalysisConfig()
    analyzer = DAOGovernanceAnalyzer()
    tracker = DecisionTracker()
    monitor = GovernanceMonitor(analyzer, tracker, config)
    dashboard = GovernanceAnalyticsDashboard(tracker, analyzer)
    
    # Add alert handler
    monitor.add_alert_handler(discord_alert_handler)
    
    # Example: Analyze existing proposals
    dao_name = "compound"
    
    try:
        # Fetch and analyze recent proposals
        proposals = analyzer.fetch_proposals(dao_name, limit=50)
        
        # Analyze proposal content
        content_analyzer = ProposalContentAnalyzer(config)
        analyzed_proposals = content_analyzer.batch_analyze_proposals(proposals)
        
        # Track decisions
        for proposal in analyzed_proposals:
            outcome_data = {
                'outcome_type': 'analysis_complete',
                'implementation_status': proposal.get('state', 'unknown'),
                'impact_metrics': proposal.get('analysis', {}),
                'follow_up_required': proposal.get('state') == 'executed',
                'notes': f"Analyzed proposal: {proposal.get('title', 'Unknown')}"
            }
            tracker.track_proposal_decision(proposal, outcome_data)
        
        # Generate analytics dashboard
        analytics = dashboard.generate_governance_dashboard(dao_name)
        
        print("=== Governance Analytics Dashboard ===")
        print(f"DAO: {dao_name}")
        print(f"Health Score: {analytics['governance_health']['health_score']:.2f}")
        print(f"Status: {analytics['governance_health']['status']}")
        print(f"Execution Rate: {analytics['basic_metrics']['execution_rate']:.2%}")
        print(f"Average Participation: {analytics['participation_analysis']['average_participation']:.0f}")
        
        # Start monitoring (in a real application, this would run continuously)
        # await monitor.start_monitoring([dao_name], check_interval=300)
        
    except Exception as e:
        print(f"Error in main execution: {e}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

# performance_optimizer.py
import asyncio
import aiohttp
from concurrent.futures import ThreadPoolExecutor
import redis
from typing import Dict, List
import json
import hashlib

class PerformanceOptimizer:
    def __init__(self, config: AnalysisConfig):
        self.config = config
        self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
        self.thread_pool = ThreadPoolExecutor(max_workers=4)
        
    async def batch_process_proposals(self, proposals: List[Dict], 
                                    batch_size: int = 10) -> List[Dict]:
        """Process proposals in optimized batches"""
        results = []
        
        # Process in batches to avoid overwhelming Ollama
        for i in range(0, len(proposals), batch_size):
            batch = proposals[i:i + batch_size]
            batch_results = await self._process_batch(batch)
            results.extend(batch_results)
            
            # Brief delay between batches
            await asyncio.sleep(0.1)
        
        return results
    
    async def _process_batch(self, batch: List[Dict]) -> List[Dict]:
        """Process a single batch of proposals"""
        tasks = []
        
        for proposal in batch:
            # Check cache first
            cached_result = self._get_cached_analysis(proposal)
            if cached_result:
                tasks.append(asyncio.create_task(self._return_cached(cached_result)))
            else:
                tasks.append(asyncio.create_task(self._analyze_proposal(proposal)))
        
        return await asyncio.gather(*tasks)
    
    def _get_cached_analysis(self, proposal: Dict) -> Optional[Dict]:
        """Get cached analysis result"""
        cache_key = self._generate_cache_key(proposal)
        cached_data = self.redis_client.get(cache_key)
        
        if cached_data:
            return json.loads(cached_data)
        return None
    
    def _cache_analysis(self, proposal: Dict, analysis: Dict):
        """Cache analysis result"""
        cache_key = self._generate_cache_key(proposal)
        cache_data = json.dumps(analysis)
        
        # Cache for 24 hours
        self.redis_client.setex(cache_key, 86400, cache_data)
    
    def _generate_cache_key(self, proposal: Dict) -> str:
        """Generate unique cache key for proposal"""
        content = f"{proposal.get('title', '')}{proposal.get('description', '')}"
        return f"proposal_analysis:{hashlib.md5(content.encode()).hexdigest()}"
    
    async def _return_cached(self, cached_result: Dict) -> Dict:
        """Return cached result asynchronously"""
        return cached_result
    
    async def _analyze_proposal(self, proposal: Dict) -> Dict:
        """Analyze proposal and cache result"""
        # Perform analysis in thread pool to avoid blocking
        loop = asyncio.get_event_loop()
        
        analyzer = ProposalContentAnalyzer(self.config)
        analysis = await loop.run_in_executor(
            self.thread_pool, 
            analyzer.analyze_proposal_content, 
            proposal
        )
        
        # Cache the result
        self._cache_analysis(proposal, analysis)
        
        return {**proposal, 'analysis': analysis}

# security_manager.py
import hashlib
import hmac
import jwt
from datetime import datetime, timedelta
from typing import Dict, Optional
import logging

class SecurityManager:
    def __init__(self, secret_key: str):
        self.secret_key = secret_key
        self.logger = logging.getLogger(__name__)
        
    def validate_proposal_data(self, proposal: Dict) -> bool:
        """Validate proposal data integrity"""
        required_fields = ['id', 'title', 'for_votes', 'against_votes', 'state']
        
        for field in required_fields:
            if field not in proposal:
                self.logger.warning(f"Missing required field: {field}")
                return False
        
        # Validate vote counts
        if not isinstance(proposal['for_votes'], int) or proposal['for_votes'] < 0:
            self.logger.warning("Invalid for_votes value")
            return False
        
        if not isinstance(proposal['against_votes'], int) or proposal['against_votes'] < 0:
            self.logger.warning("Invalid against_votes value")
            return False
        
        return True
    
    def sanitize_analysis_output(self, analysis: Dict) -> Dict:
        """Sanitize analysis output for safe storage"""
        # Remove potentially sensitive information
        sanitized = analysis.copy()
        
        # Remove any personal identifiers
        if 'proposer' in sanitized:
            # Hash the proposer address for privacy
            sanitized['proposer'] = hashlib.sha256(
                sanitized['proposer'].encode()
            ).hexdigest()[:16]
        
        return sanitized
    
    def generate_api_token(self, user_id: str, permissions: List[str]) -> str:
        """Generate JWT token for API access"""
        payload = {
            'user_id': user_id,
            'permissions': permissions,
            'exp': datetime.utcnow() + timedelta(hours=24),
            'iat': datetime.utcnow()
        }
        
        return jwt.encode(payload, self.secret_key, algorithm='HS256')
    
    def validate_api_token(self, token: str) -> Optional[Dict]:
        """Validate JWT token"""
        try:
            payload = jwt.decode(token, self.secret_key, algorithms=['HS256'])
            return payload
        except jwt.ExpiredSignatureError:
            self.logger.warning("Token has expired")
            return None
        except jwt.InvalidTokenError:
            self.logger.warning("Invalid token")
            return None