How to Analyze Trump Media ETF Holdings with Ollama: BTC, ETH, SOL, XRP, CRO

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

# Verify installation
ollama --version

# Pull the recommended model for financial analysis
ollama pull llama2:13b

# Test the installation
ollama run llama2:13b "Hello, I need help with ETF analysis"

import requests
import pandas as pd
from datetime import datetime, timedelta
import json

def fetch_crypto_data(symbols, days=30):
    """
    Fetch cryptocurrency data for Trump Media ETF holdings
    symbols: List of crypto symbols ['BTC', 'ETH', 'SOL', 'XRP', 'CRO']
    days: Number of days of historical data
    """
    
    base_url = "https://api.coingecko.com/api/v3"
    crypto_data = {}
    
    # Mapping symbols to CoinGecko IDs
    symbol_map = {
        'BTC': 'bitcoin',
        'ETH': 'ethereum', 
        'SOL': 'solana',
        'XRP': 'ripple',
        'CRO': 'crypto-com-chain'
    }
    
    for symbol in symbols:
        coin_id = symbol_map.get(symbol)
        if not coin_id:
            continue
            
        # Fetch price history
        url = f"{base_url}/coins/{coin_id}/market_chart"
        params = {
            'vs_currency': 'usd',
            'days': days,
            'interval': 'daily'
        }
        
        try:
            response = requests.get(url, params=params)
            data = response.json()
            
            # Process price data
            prices = data['prices']
            volumes = data['total_volumes']
            
            crypto_data[symbol] = {
                'prices': prices,
                'volumes': volumes,
                'current_price': prices[-1][1] if prices else 0
            }
            
            print(f"✓ Fetched {symbol} data: ${prices[-1][1]:.2f}")
            
        except Exception as e:
            print(f"✗ Error fetching {symbol}: {e}")
    
    return crypto_data

# Example usage
trump_media_holdings = ['BTC', 'ETH', 'SOL', 'XRP', 'CRO']
holdings_data = fetch_crypto_data(trump_media_holdings)

def create_analysis_prompt(holdings_data, etf_weights):
    """
    Generate comprehensive analysis prompt for Ollama
    holdings_data: Dictionary of cryptocurrency price/volume data
    etf_weights: Dictionary of ETF allocation percentages
    """
    
    prompt = f"""
    Analyze Trump Media ETF cryptocurrency holdings based on this data:
    
    Current Holdings:
    - BTC: {holdings_data['BTC']['current_price']:.2f} USD ({etf_weights.get('BTC', 0)}% allocation)
    - ETH: {holdings_data['ETH']['current_price']:.2f} USD ({etf_weights.get('ETH', 0)}% allocation)
    - SOL: {holdings_data['SOL']['current_price']:.2f} USD ({etf_weights.get('SOL', 0)}% allocation)
    - XRP: {holdings_data['XRP']['current_price']:.2f} USD ({etf_weights.get('XRP', 0)}% allocation)
    - CRO: {holdings_data['CRO']['current_price']:.2f} USD ({etf_weights.get('CRO', 0)}% allocation)
    
    Please provide:
    1. Risk assessment for each holding
    2. Correlation analysis between assets
    3. Diversification effectiveness
    4. Rebalancing recommendations
    5. Market outlook for next 30 days
    
    Focus on actionable insights for portfolio optimization.
    """
    
    return prompt

# Example ETF weights (hypothetical allocation)
etf_allocation = {
    'BTC': 40.0,
    'ETH': 25.0,
    'SOL': 15.0,
    'XRP': 10.0,
    'CRO': 10.0
}

analysis_prompt = create_analysis_prompt(holdings_data, etf_allocation)

# Save the analysis prompt to a file
echo "Your analysis prompt here" > etf_analysis_prompt.txt

# Run Ollama analysis
ollama run llama2:13b < etf_analysis_prompt.txt > analysis_results.txt

# View the results
cat analysis_results.txt

import numpy as np
import pandas as pd
from scipy import stats

def calculate_performance_metrics(holdings_data, weights):
    """
    Calculate comprehensive performance metrics for ETF holdings
    holdings_data: Dictionary of price data
    weights: Dictionary of allocation weights
    """
    
    metrics = {}
    
    for symbol, data in holdings_data.items():
        prices = [price[1] for price in data['prices']]
        returns = np.diff(prices) / prices[:-1]
        
        # Calculate key metrics
        metrics[symbol] = {
            'total_return': ((prices[-1] / prices[0]) - 1) * 100,
            'volatility': np.std(returns) * np.sqrt(252) * 100,
            'sharpe_ratio': np.mean(returns) / np.std(returns) * np.sqrt(252),
            'max_drawdown': calculate_max_drawdown(prices),
            'weight': weights.get(symbol, 0)
        }
        
        print(f"{symbol} Performance:")
        print(f"  Total Return: {metrics[symbol]['total_return']:.2f}%")
        print(f"  Volatility: {metrics[symbol]['volatility']:.2f}%")
        print(f"  Sharpe Ratio: {metrics[symbol]['sharpe_ratio']:.2f}")
        print(f"  Max Drawdown: {metrics[symbol]['max_drawdown']:.2f}%")
        print(f"  ETF Weight: {metrics[symbol]['weight']:.1f}%\n")
    
    return metrics

def calculate_max_drawdown(prices):
    """Calculate maximum drawdown from price series"""
    peak = prices[0]
    max_dd = 0
    
    for price in prices:
        if price > peak:
            peak = price
        drawdown = (peak - price) / peak * 100
        max_dd = max(max_dd, drawdown)
    
    return max_dd

# Calculate performance metrics
performance_metrics = calculate_performance_metrics(holdings_data, etf_allocation)

def analyze_correlations(holdings_data):
    """
    Calculate correlation matrix for cryptocurrency holdings
    """
    
    # Prepare price data
    price_data = {}
    for symbol, data in holdings_data.items():
        prices = [price[1] for price in data['prices']]
        returns = np.diff(prices) / prices[:-1]
        price_data[symbol] = returns
    
    # Create correlation matrix
    df = pd.DataFrame(price_data)
    correlation_matrix = df.corr()
    
    print("Correlation Matrix:")
    print(correlation_matrix.round(3))
    
    # Identify diversification opportunities
    print("\nDiversification Analysis:")
    for i, symbol1 in enumerate(correlation_matrix.columns):
        for j, symbol2 in enumerate(correlation_matrix.columns):
            if i < j:
                corr = correlation_matrix.iloc[i, j]
                if abs(corr) < 0.3:
                    print(f"✓ {symbol1}-{symbol2}: Low correlation ({corr:.3f}) - Good diversification")
                elif abs(corr) > 0.7:
                    print(f"⚠ {symbol1}-{symbol2}: High correlation ({corr:.3f}) - Limited diversification")
    
    return correlation_matrix

# Analyze correlations
correlation_results = analyze_correlations(holdings_data)

def assess_portfolio_risk(metrics, correlation_matrix, weights):
    """
    Calculate portfolio-level risk metrics
    """
    
    # Calculate weighted portfolio metrics
    portfolio_return = sum(metrics[symbol]['total_return'] * weights[symbol] / 100 
                          for symbol in metrics.keys())
    
    # Portfolio volatility using correlation matrix
    symbols = list(weights.keys())
    weight_vector = np.array([weights[symbol] / 100 for symbol in symbols])
    vol_vector = np.array([metrics[symbol]['volatility'] / 100 for symbol in symbols])
    
    # Portfolio variance calculation
    portfolio_variance = np.dot(weight_vector.T, np.dot(correlation_matrix.values, weight_vector))
    portfolio_vol = np.sqrt(portfolio_variance) * 100
    
    # Risk-adjusted return
    portfolio_sharpe = portfolio_return / portfolio_vol if portfolio_vol > 0 else 0
    
    risk_assessment = {
        'portfolio_return': portfolio_return,
        'portfolio_volatility': portfolio_vol,
        'portfolio_sharpe': portfolio_sharpe,
        'diversification_ratio': sum(vol_vector * weight_vector) / (portfolio_vol / 100)
    }
    
    print("Portfolio Risk Assessment:")
    print(f"Expected Return: {risk_assessment['portfolio_return']:.2f}%")
    print(f"Portfolio Volatility: {risk_assessment['portfolio_volatility']:.2f}%")
    print(f"Portfolio Sharpe Ratio: {risk_assessment['portfolio_sharpe']:.2f}")
    print(f"Diversification Ratio: {risk_assessment['diversification_ratio']:.2f}")
    
    return risk_assessment

# Assess portfolio risk
risk_results = assess_portfolio_risk(performance_metrics, correlation_results, etf_allocation)

def generate_ollama_report(performance_metrics, risk_results, correlation_matrix):
    """
    Generate comprehensive ETF analysis report using Ollama
    """
    
    # Prepare report data
    report_prompt = f"""
    Generate a professional ETF analysis report for Trump Media cryptocurrency holdings:
    
    PERFORMANCE SUMMARY:
    Portfolio Return: {risk_results['portfolio_return']:.2f}%
    Portfolio Volatility: {risk_results['portfolio_volatility']:.2f}%
    Sharpe Ratio: {risk_results['portfolio_sharpe']:.2f}
    Diversification Ratio: {risk_results['diversification_ratio']:.2f}
    
    INDIVIDUAL HOLDINGS:
    {format_holdings_data(performance_metrics)}
    
    CORRELATION INSIGHTS:
    {format_correlation_data(correlation_matrix)}
    
    Please provide:
    1. Executive summary with key findings
    2. Risk assessment and recommendations
    3. Rebalancing suggestions
    4. Market outlook and strategy adjustments
    5. Action items for portfolio optimization
    
    Format as a professional investment report.
    """
    
    return report_prompt

def format_holdings_data(metrics):
    """Format holdings data for report"""
    formatted = ""
    for symbol, data in metrics.items():
        formatted += f"{symbol}: Return {data['total_return']:.2f}%, Vol {data['volatility']:.2f}%, Weight {data['weight']:.1f}%\n"
    return formatted

def format_correlation_data(correlation_matrix):
    """Format correlation data for report"""
    correlations = []
    for i in range(len(correlation_matrix.columns)):
        for j in range(i+1, len(correlation_matrix.columns)):
            symbol1 = correlation_matrix.columns[i]
            symbol2 = correlation_matrix.columns[j]
            corr = correlation_matrix.iloc[i, j]
            correlations.append(f"{symbol1}-{symbol2}: {corr:.3f}")
    return "\n".join(correlations)

# Generate and save report
report_prompt = generate_ollama_report(performance_metrics, risk_results, correlation_results)

# Save to file for Ollama processing
with open('etf_report_prompt.txt', 'w') as f:
    f.write(report_prompt)

print("Report prompt saved. Run: ollama run llama2:13b < etf_report_prompt.txt")

def calculate_optimal_weights(metrics, correlation_matrix, risk_budget=0.15):
    """
    Calculate optimal portfolio weights using risk-parity approach
    risk_budget: Maximum acceptable portfolio volatility
    """
    
    symbols = list(metrics.keys())
    volatilities = [metrics[symbol]['volatility'] / 100 for symbol in symbols]
    
    # Risk-parity weights (inverse volatility)
    inv_vol_weights = [1/vol for vol in volatilities]
    total_inv_vol = sum(inv_vol_weights)
    risk_parity_weights = [w/total_inv_vol for w in inv_vol_weights]
    
    # Calculate resulting portfolio volatility
    weight_vector = np.array(risk_parity_weights)
    vol_vector = np.array(volatilities)
    
    portfolio_vol = np.sqrt(np.dot(weight_vector.T, 
                                  np.dot(correlation_matrix.values, weight_vector)))
    
    # Scale weights if portfolio volatility exceeds risk budget
    if portfolio_vol > risk_budget:
        scale_factor = risk_budget / portfolio_vol
        risk_parity_weights = [w * scale_factor for w in risk_parity_weights]
    
    optimization_results = {
        'optimal_weights': dict(zip(symbols, risk_parity_weights)),
        'expected_volatility': portfolio_vol,
        'risk_budget_utilization': portfolio_vol / risk_budget * 100
    }
    
    print("Optimization Results:")
    print(f"Expected Portfolio Volatility: {portfolio_vol*100:.2f}%")
    print(f"Risk Budget Utilization: {optimization_results['risk_budget_utilization']:.1f}%")
    print("\nOptimal Weights:")
    for symbol, weight in optimization_results['optimal_weights'].items():
        current_weight = etf_allocation.get(symbol, 0)
        print(f"{symbol}: {weight*100:.1f}% (current: {current_weight:.1f}%)")
    
    return optimization_results

# Calculate optimal weights
optimization_results = calculate_optimal_weights(performance_metrics, correlation_results)

def setup_monitoring_alerts(holdings_data, alert_thresholds):
    """
    Set up monitoring alerts for ETF holdings
    alert_thresholds: Dictionary of alert criteria
    """
    
    alerts = []
    
    for symbol, data in holdings_data.items():
        current_price = data['current_price']
        
        # Price movement alerts
        if 'price_change_24h' in alert_thresholds:
            threshold = alert_thresholds['price_change_24h']
            # Calculate 24h change (simplified)
            recent_prices = [p[1] for p in data['prices'][-2:]]
            if len(recent_prices) >= 2:
                change_pct = (recent_prices[-1] / recent_prices[-2] - 1) * 100
                if abs(change_pct) > threshold:
                    alerts.append({
                        'symbol': symbol,
                        'type': 'price_movement',
                        'message': f"{symbol} moved {change_pct:.2f}% in 24h",
                        'severity': 'high' if abs(change_pct) > threshold * 1.5 else 'medium'
                    })
        
        # Volatility alerts
        if 'volatility_spike' in alert_thresholds:
            prices = [p[1] for p in data['prices']]
            returns = np.diff(prices) / prices[:-1]
            recent_vol = np.std(returns[-7:]) * np.sqrt(252) * 100  # 7-day volatility
            
            if recent_vol > alert_thresholds['volatility_spike']:
                alerts.append({
                    'symbol': symbol,
                    'type': 'volatility_spike',
                    'message': f"{symbol} volatility spiked to {recent_vol:.1f}%",
                    'severity': 'high'
                })
    
    # Display alerts
    if alerts:
        print("🚨 PORTFOLIO ALERTS:")
        for alert in alerts:
            severity_icon = "🔴" if alert['severity'] == 'high' else "🟡"
            print(f"{severity_icon} {alert['message']}")
    else:
        print("✅ No alerts - portfolio within normal parameters")
    
    return alerts

# Set up alert thresholds
alert_config = {
    'price_change_24h': 10.0,  # 10% price change threshold
    'volatility_spike': 80.0   # 80% annualized volatility threshold
}

# Monitor for alerts
current_alerts = setup_monitoring_alerts(holdings_data, alert_config)

def integrate_trading_system(optimization_results, current_portfolio):
    """
    Generate trading signals based on optimization results
    """
    
    trading_signals = []
    
    for symbol, optimal_weight in optimization_results['optimal_weights'].items():
        current_weight = current_portfolio.get(symbol, 0) / 100
        weight_diff = optimal_weight - current_weight
        
        # Generate trading signal if difference exceeds threshold
        if abs(weight_diff) > 0.02:  # 2% threshold
            action = 'BUY' if weight_diff > 0 else 'SELL'
            quantity = abs(weight_diff) * 100  # Convert to percentage
            
            trading_signals.append({
                'symbol': symbol,
                'action': action,
                'target_weight': optimal_weight * 100,
                'current_weight': current_weight * 100,
                'adjustment': quantity,
                'priority': 'high' if abs(weight_diff) > 0.05 else 'medium'
            })
    
    return trading_signals

# Generate trading signals
current_portfolio = etf_allocation.copy()
trading_signals = integrate_trading_system(optimization_results, current_portfolio)

print("Trading Signals:")
for signal in trading_signals:
    print(f"{signal['action']} {signal['symbol']}: "
          f"Adjust by {signal['adjustment']:.1f}% "
          f"(Target: {signal['target_weight']:.1f}%)")