Trump vs Biden Crypto Policies: Ollama Sentiment Analysis and Market Impact 2025

# Install Ollama (Linux/Mac)
curl -fsSL https://ollama.com/install.sh | sh

# Pull the model for sentiment analysis
ollama pull llama3.1:8b

import ollama
import pandas as pd
import requests
from datetime import datetime
import json

class CryptoPolicyAnalyzer:
    """Analyze crypto policy sentiment using Ollama"""
    
    def __init__(self, model_name="llama3.1:8b"):
        self.model_name = model_name
        self.analysis_results = []
    
    def analyze_policy_sentiment(self, text, policy_type="general"):
        """Analyze sentiment of crypto policy text"""
        
        prompt = f"""
        Analyze the sentiment of this crypto policy statement:
        
        Text: {text}
        
        Provide analysis in this format:
        1. Sentiment: (Bullish/Bearish/Neutral)
        2. Confidence: (0-100%)
        3. Key factors influencing sentiment
        4. Potential market impact
        5. Risk assessment (1-10 scale)
        """
        
        try:
            response = ollama.chat(
                model=self.model_name,
                messages=[{
                    'role': 'user',
                    'content': prompt
                }]
            )
            
            return {
                'text': text,
                'policy_type': policy_type,
                'analysis': response['message']['content'],
                'timestamp': datetime.now().isoformat()
            }
            
        except Exception as e:
            return {'error': str(e)}
    
    def compare_policies(self, trump_text, biden_text):
        """Compare Trump vs Biden crypto policy sentiment"""
        
        trump_analysis = self.analyze_policy_sentiment(trump_text, "Trump")
        biden_analysis = self.analyze_policy_sentiment(biden_text, "Biden")
        
        comparison_prompt = f"""
        Compare these two crypto policy approaches:
        
        Trump Policy: {trump_text}
        Biden Policy: {biden_text}
        
        Provide:
        1. Market sentiment comparison
        2. Investment implications
        3. Regulatory uncertainty levels
        4. Long-term crypto adoption impact
        5. Winner for crypto investors
        """
        
        comparison = ollama.chat(
            model=self.model_name,
            messages=[{
                'role': 'user',
                'content': comparison_prompt
            }]
        )
        
        return {
            'trump_analysis': trump_analysis,
            'biden_analysis': biden_analysis,
            'comparison': comparison['message']['content']
        }

# Example usage
analyzer = CryptoPolicyAnalyzer()

# Trump policy text
trump_policy = """
President Trump signed an executive order to establish a Strategic Bitcoin Reserve 
and position the United States as the crypto capital of the world. The order 
prohibits CBDCs and promotes responsible growth of digital assets.
"""

# Biden policy text
biden_policy = """
Executive Order 14067 focuses on responsible development of digital assets with 
emphasis on consumer protection, regulatory oversight, and potential CBDC development 
to address risks in the digital asset ecosystem.
"""

# Analyze both policies
results = analyzer.compare_policies(trump_policy, biden_policy)
print(json.dumps(results, indent=2))

class CryptoMarketImpactAnalyzer:
    """Analyze market impact of crypto policies"""
    
    def __init__(self):
        self.price_data = {}
        self.sentiment_scores = {}
    
    def fetch_crypto_prices(self, symbols=['BTC', 'ETH', 'SOL']):
        """Fetch current crypto prices for analysis"""
        # Placeholder for price fetching logic
        # In production, integrate with CoinGecko or similar API
        return {
            'BTC': 43250,
            'ETH': 2650,
            'SOL': 98.5
        }
    
    def analyze_policy_impact(self, policy_text, crypto_symbol):
        """Analyze how policy affects specific crypto"""
        
        prompt = f"""
        Analyze how this crypto policy affects {crypto_symbol}:
        
        Policy: {policy_text}
        
        Provide:
        1. Direct impact on {crypto_symbol} (Positive/Negative/Neutral)
        2. Short-term price prediction (next 30 days)
        3. Long-term implications (6-12 months)
        4. Risk factors specific to {crypto_symbol}
        5. Investment recommendation
        """
        
        response = ollama.chat(
            model="llama3.1:8b",
            messages=[{
                'role': 'user',
                'content': prompt
            }]
        )
        
        return response['message']['content']
    
    def generate_trading_signals(self, sentiment_data):
        """Generate trading signals based on sentiment analysis"""
        
        signals = []
        for crypto, sentiment in sentiment_data.items():
            if sentiment > 0.7:
                signals.append(f"BUY {crypto} - Strong bullish sentiment")
            elif sentiment < 0.3:
                signals.append(f"SELL {crypto} - Strong bearish sentiment")
            else:
                signals.append(f"HOLD {crypto} - Neutral sentiment")
        
        return signals

# Example market impact analysis
impact_analyzer = CryptoMarketImpactAnalyzer()

trump_bitcoin_impact = impact_analyzer.analyze_policy_impact(
    "Strategic Bitcoin Reserve establishment with no-sale policy",
    "BTC"
)

print("Trump Policy Impact on Bitcoin:")
print(trump_bitcoin_impact)

import schedule
import time
from datetime import datetime

class PolicyMonitor:
    """Monitor crypto policy changes and sentiment"""
    
    def __init__(self):
        self.analyzer = CryptoPolicyAnalyzer()
        self.alerts = []
    
    def monitor_policy_changes(self):
        """Check for new policy developments"""
        
        # Fetch latest policy news
        policy_sources = [
            "https://www.whitehouse.gov/briefings-statements/",
            "https://www.sec.gov/news/press-releases",
            "https://www.treasury.gov/press-center/"
        ]
        
        # Analyze sentiment of new announcements
        for source in policy_sources:
            # Implementation would fetch and analyze new content
            pass
    
    def generate_alerts(self, sentiment_threshold=0.8):
        """Generate alerts for significant sentiment changes"""
        
        # Monitor for major policy shifts
        policy_text = "Sample policy announcement text"
        analysis = self.analyzer.analyze_policy_sentiment(policy_text)
        
        # Generate alerts based on sentiment score
        if "Bullish" in analysis.get('analysis', ''):
            self.alerts.append({
                'type': 'BULLISH_POLICY',
                'timestamp': datetime.now(),
                'message': 'Strong bullish crypto policy detected'
            })
        
        return self.alerts

# Schedule monitoring
monitor = PolicyMonitor()
schedule.every(1).hours.do(monitor.monitor_policy_changes)

# Run monitoring loop
while True:
    schedule.run_pending()
    time.sleep(60)

import pandas as pd
import numpy as np

class PolicyBacktester:
    """Backtest crypto performance against policy changes"""
    
    def __init__(self):
        self.policy_events = []
        self.price_data = pd.DataFrame()
    
    def load_policy_events(self):
        """Load historical policy events"""
        self.policy_events = [
            {'date': '2022-03-09', 'event': 'Biden EO 14067', 'sentiment': 'Bearish'},
            {'date': '2025-01-23', 'event': 'Trump Crypto EO', 'sentiment': 'Bullish'},
            {'date': '2025-03-07', 'event': 'Bitcoin Reserve', 'sentiment': 'Very Bullish'}
        ]
    
    def analyze_policy_correlation(self, crypto_symbol='BTC'):
        """Analyze correlation between policy and price"""
        
        correlations = []
        for event in self.policy_events:
            # Calculate price movement 30 days after policy
            pre_policy_price = self.get_price_at_date(event['date'])
            post_policy_price = self.get_price_at_date(
                event['date'], days_offset=30
            )
            
            change_percent = ((post_policy_price - pre_policy_price) / 
                            pre_policy_price) * 100
            
            correlations.append({
                'event': event['event'],
                'sentiment': event['sentiment'],
                'price_change': change_percent
            })
        
        return pd.DataFrame(correlations)
    
    def get_price_at_date(self, date, days_offset=0):
        """Get crypto price at specific date"""
        # Placeholder for price fetching logic
        return 40000  # Example BTC price

# Run backtesting
backtester = PolicyBacktester()
backtester.load_policy_events()
results = backtester.analyze_policy_correlation()
print(results)

def track_social_sentiment():
    """Track social media sentiment about crypto policies"""
    
    # Sample social media analysis
    social_texts = [
        "Trump's Bitcoin reserve is genius! Finally a president who gets crypto! 🚀",
        "Biden's approach was more measured and focused on consumer protection.",
        "Regulatory clarity is what we needed all along. Bullish on America! 🇺🇸"
    ]
    
    analyzer = CryptoPolicyAnalyzer()
    
    for text in social_texts:
        sentiment = analyzer.analyze_policy_sentiment(text, "social_media")
        print(f"Text: {text}")
        print(f"Sentiment: {sentiment}")
        print("-" * 50)

# Run social sentiment analysis
track_social_sentiment()

class CryptoRiskManager:
    """Manage crypto investment risks based on policy analysis"""
    
    def __init__(self):
        self.risk_factors = {
            'regulatory_risk': 0.3,
            'market_volatility': 0.5,
            'policy_uncertainty': 0.2
        }
    
    def calculate_position_size(self, sentiment_score, portfolio_value):
        """Calculate optimal position size based on sentiment"""
        
        base_allocation = 0.05  # 5% base allocation
        sentiment_multiplier = sentiment_score * 2  # Scale sentiment impact
        
        # Adjust for risk factors
        risk_adjustment = 1 - sum(self.risk_factors.values()) / 3
        
        optimal_size = (base_allocation * sentiment_multiplier * 
                       risk_adjustment * portfolio_value)
        
        return min(optimal_size, portfolio_value * 0.25)  # Cap at 25%
    
    def generate_risk_report(self):
        """Generate comprehensive risk assessment"""
        
        return {
            'current_risk_level': 'MODERATE',
            'key_risks': ['Policy reversal', 'Market volatility', 'Regulatory changes'],
            'mitigation_strategies': ['Diversification', 'Stop-losses', 'Position sizing']
        }

# Example risk management
risk_manager = CryptoRiskManager()
position_size = risk_manager.calculate_position_size(0.8, 100000)
print(f"Recommended position size: ${position_size:,.2f}")