Crypto ETF Liquidity Analysis: Ollama Trading Volume and Market Impact Guide

import pandas as pd
import numpy as np
import yfinance as yf
from datetime import datetime, timedelta

# Fetch Ollama ETF data (example ticker: OLLM)
def get_etf_data(ticker, period='1y'):
    """
    Retrieve ETF trading data with volume metrics
    Returns: DataFrame with OHLCV data
    """
    etf = yf.Ticker(ticker)
    data = etf.history(period=period)
    
    # Add volume-based metrics
    data['volume_ma_20'] = data['Volume'].rolling(20).mean()
    data['relative_volume'] = data['Volume'] / data['volume_ma_20']
    
    return data

# Example usage
ollama_data = get_etf_data('OLLM')
print(f"Data shape: {ollama_data.shape}")
print(f"Average daily volume: {ollama_data['Volume'].mean():,.0f}")

def clean_trading_data(df):
    """
    Clean and validate ETF trading data
    Returns: Cleaned DataFrame
    """
    # Remove weekends and holidays with zero volume
    df = df[df['Volume'] > 0].copy()
    
    # Flag unusual volume spikes (>5x average)
    avg_volume = df['Volume'].rolling(30).mean()
    df['volume_spike'] = df['Volume'] > (avg_volume * 5)
    
    # Calculate returns for volatility analysis
    df['returns'] = df['Close'].pct_change()
    df['volatility_20d'] = df['returns'].rolling(20).std() * np.sqrt(252)
    
    return df

clean_data = clean_trading_data(ollama_data)

def calculate_vwap(df, window=20):
    """
    Calculate Volume Weighted Average Price
    Args: df (DataFrame), window (int) - rolling window size
    Returns: Series with VWAP values
    """
    typical_price = (df['High'] + df['Low'] + df['Close']) / 3
    cumulative_volume = df['Volume'].rolling(window).sum()
    cumulative_value = (typical_price * df['Volume']).rolling(window).sum()
    
    return cumulative_value / cumulative_volume

clean_data['vwap_20'] = calculate_vwap(clean_data, 20)

# Compare closing price to VWAP
clean_data['price_vs_vwap'] = (clean_data['Close'] / clean_data['vwap_20'] - 1) * 100

print(f"Average price deviation from VWAP: {clean_data['price_vs_vwap'].mean():.2f}%")

def calculate_liquidity_metrics(df, shares_outstanding):
    """
    Calculate comprehensive liquidity metrics
    Args: df (DataFrame), shares_outstanding (int)
    Returns: DataFrame with added metrics
    """
    # Market cap and turnover
    market_cap = df['Close'] * shares_outstanding
    df['turnover_ratio'] = df['Volume'] / shares_outstanding * 100
    
    # Amihud illiquidity measure
    df['amihud_illiq'] = np.abs(df['returns']) / (df['Volume'] * df['Close']) * 1e6
    
    # Volume-based liquidity score
    avg_volume = df['Volume'].rolling(60).mean()
    volume_std = df['Volume'].rolling(60).std()
    df['liquidity_score'] = (df['Volume'] - avg_volume) / volume_std
    
    return df

# Assume 100 million shares outstanding
liquidity_data = calculate_liquidity_metrics(clean_data, 100_000_000)

print(f"Average daily turnover: {liquidity_data['turnover_ratio'].mean():.2f}%")
print(f"Median Amihud illiquidity: {liquidity_data['amihud_illiq'].median():.2f}")

def analyze_market_impact(df, volume_threshold=1.5):
    """
    Analyze relationship between volume and price impact
    Args: df (DataFrame), volume_threshold (float) - multiple of average volume
    Returns: Impact analysis results
    """
    # Identify high-volume trading days
    avg_volume = df['Volume'].rolling(30).mean()
    high_volume_days = df['Volume'] > (avg_volume * volume_threshold)
    
    # Calculate next-day price impact
    df['next_day_return'] = df['returns'].shift(-1)
    df['high_volume'] = high_volume_days
    
    # Group by volume categories
    impact_analysis = df.groupby('high_volume').agg({
        'returns': ['mean', 'std'],
        'next_day_return': ['mean', 'std'],
        'Volume': 'mean'
    }).round(4)
    
    return impact_analysis

impact_results = analyze_market_impact(liquidity_data)
print("Market Impact Analysis:")
print(impact_results)

def estimate_spread_impact(df):
    """
    Estimate bid-ask spread using high-low range
    Returns: DataFrame with spread estimates
    """
    # Approximate spread using daily range
    df['estimated_spread'] = ((df['High'] - df['Low']) / df['Close']) * 100
    
    # Smooth spreads with moving average
    df['spread_ma_10'] = df['estimated_spread'].rolling(10).mean()
    
    # Identify spread expansion periods
    spread_threshold = df['spread_ma_10'].quantile(0.75)
    df['wide_spread_period'] = df['spread_ma_10'] > spread_threshold
    
    # Calculate spread-volume correlation
    spread_volume_corr = df['estimated_spread'].corr(df['Volume'])
    
    return df, spread_volume_corr

spread_data, correlation = estimate_spread_impact(liquidity_data)
print(f"Spread-Volume Correlation: {correlation:.3f}")
print(f"Average estimated spread: {spread_data['estimated_spread'].mean():.2f}%")

def create_liquidity_index(df):
    """
    Build composite liquidity index from multiple metrics
    Returns: DataFrame with liquidity index
    """
    # Normalize metrics to 0-100 scale
    from sklearn.preprocessing import MinMaxScaler
    scaler = MinMaxScaler(feature_range=(0, 100))
    
    # Select liquidity metrics
    metrics = ['turnover_ratio', 'relative_volume', 'liquidity_score']
    
    # Invert illiquidity measures (lower is better)
    df['inv_amihud'] = 1 / (df['amihud_illiq'] + 0.001)
    df['inv_spread'] = 1 / (df['estimated_spread'] + 0.001)
    
    metrics.extend(['inv_amihud', 'inv_spread'])
    
    # Scale and combine metrics
    scaled_metrics = scaler.fit_transform(df[metrics].fillna(0))
    df['liquidity_index'] = np.mean(scaled_metrics, axis=1)
    
    # Categorize liquidity levels
    df['liquidity_category'] = pd.cut(
        df['liquidity_index'], 
        bins=[0, 25, 50, 75, 100],
        labels=['Poor', 'Fair', 'Good', 'Excellent']
    )
    
    return df

final_data = create_liquidity_index(spread_data)

# Display liquidity distribution
liquidity_dist = final_data['liquidity_category'].value_counts()
print("Liquidity Distribution:")
print(liquidity_dist)

def daily_liquidity_report(ticker):
    """
    Generate daily liquidity summary report
    Returns: Dictionary with key metrics
    """
    # Get recent data
    data = get_etf_data(ticker, period='3mo')
    cleaned = clean_trading_data(data)
    
    # Calculate recent metrics
    latest_data = cleaned.tail(5)
    
    report = {
        'current_volume': latest_data['Volume'].iloc[-1],
        'avg_volume_5d': latest_data['Volume'].mean(),
        'volume_trend': 'Increasing' if latest_data['Volume'].iloc[-1] > latest_data['Volume'].mean() else 'Decreasing',
        'relative_volume': latest_data['relative_volume'].iloc[-1],
        'estimated_spread': latest_data['estimated_spread'].iloc[-1] if 'estimated_spread' in latest_data.columns else None
    }
    
    return report

# Example daily monitoring
daily_report = daily_liquidity_report('OLLM')
print("Daily Liquidity Report:")
for metric, value in daily_report.items():
    print(f"{metric}: {value}")

def liquidity_adjusted_position_size(base_size, liquidity_index, max_daily_volume):
    """
    Adjust position size based on liquidity conditions
    Args: base_size (int), liquidity_index (float), max_daily_volume (int)
    Returns: Adjusted position size
    """
    # Scale down position in poor liquidity
    if liquidity_index < 25:
        adjustment_factor = 0.5
    elif liquidity_index < 50:
        adjustment_factor = 0.75
    else:
        adjustment_factor = 1.0
    
    # Limit to percentage of daily volume
    volume_limit = max_daily_volume * 0.05  # 5% of daily volume
    
    adjusted_size = min(
        base_size * adjustment_factor,
        volume_limit
    )
    
    return int(adjusted_size)

# Example position sizing
target_position = 10000
current_liquidity = final_data['liquidity_index'].iloc[-1]
recent_volume = final_data['Volume'].iloc[-1]

recommended_size = liquidity_adjusted_position_size(
    target_position, 
    current_liquidity, 
    recent_volume
)

print(f"Target position: {target_position:,}")
print(f"Recommended size: {recommended_size:,}")
print(f"Adjustment: {(recommended_size/target_position-1)*100:.1f}%")

def measure_execution_quality(executed_trades, market_data):
    """
    Analyze execution quality vs liquidity conditions
    Args: executed_trades (DataFrame), market_data (DataFrame)
    Returns: Execution quality metrics
    """
    # Merge trade data with market conditions
    merged = executed_trades.merge(
        market_data[['liquidity_index', 'vwap_20', 'estimated_spread']], 
        left_on='date', 
        right_index=True
    )
    
    # Calculate execution metrics
    merged['vwap_slippage'] = (merged['executed_price'] / merged['vwap_20'] - 1) * 100
    merged['spread_cost'] = merged['estimated_spread'] / 2  # Half spread as cost estimate
    
    # Group by liquidity conditions
    quality_by_liquidity = merged.groupby(
        pd.cut(merged['liquidity_index'], bins=[0, 25, 50, 75, 100])
    ).agg({
        'vwap_slippage': ['mean', 'std'],
        'spread_cost': 'mean'
    }).round(3)
    
    return quality_by_liquidity

# Example execution analysis (placeholder data)
sample_trades = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=50, freq='D'),
    'executed_price': np.random.normal(100, 2, 50),
    'size': np.random.randint(1000, 10000, 50)
})

# quality_results = measure_execution_quality(sample_trades, final_data)
print("Execution quality analysis ready for live trade data")