Seasonal Trading Patterns with Ollama: Calendar Effects and Holiday Analysis

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

# Pull a suitable model for Data Analysis
ollama pull llama3.1:8b

# requirements.txt
pandas==2.1.0
numpy==1.24.3
yfinance==0.2.18
requests==2.31.0
matplotlib==3.7.2
seaborn==0.12.2

pip install -r requirements.txt

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

class OllamaTrader:
    def __init__(self, model_name="llama3.1:8b"):
        self.model = model_name
        self.base_url = "http://localhost:11434/api/generate"
    
    def query_ollama(self, prompt):
        """Send analysis request to Ollama"""
        payload = {
            "model": self.model,
            "prompt": prompt,
            "stream": False
        }
        
        response = requests.post(self.base_url, json=payload)
        return json.loads(response.text)["response"]

def analyze_monthly_patterns(symbol, years=10):
    """Analyze monthly trading patterns using Ollama"""
    # Fetch historical data
    end_date = datetime.now()
    start_date = end_date - timedelta(days=years*365)
    
    stock = yf.download(symbol, start=start_date, end=end_date)
    
    # Calculate monthly returns
    monthly_data = stock['Close'].resample('M').last().pct_change()
    monthly_stats = monthly_data.groupby(monthly_data.index.month).agg([
        'mean', 'std', 'count'
    ])
    
    # Prepare data for Ollama analysis
    monthly_summary = monthly_stats.round(4).to_string()
    
    prompt = f"""
    Analyze these monthly return patterns for {symbol}:
    
    {monthly_summary}
    
    Identify:
    1. Strongest performing months
    2. Weakest performing months  
    3. Months with highest volatility
    4. Statistical significance of patterns
    5. Trading opportunities based on calendar effects
    
    Provide specific actionable insights.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return {
        'data': monthly_stats,
        'analysis': analysis
    }

# Example usage
spy_monthly = analyze_monthly_patterns('SPY', years=15)
print(spy_monthly['analysis'])

def analyze_weekday_patterns(symbol, years=5):
    """Detect day-of-week trading effects"""
    end_date = datetime.now()
    start_date = end_date - timedelta(days=years*365)
    
    stock = yf.download(symbol, start=start_date, end=end_date)
    
    # Calculate daily returns by weekday
    stock['Returns'] = stock['Close'].pct_change()
    stock['Weekday'] = stock.index.dayofweek
    
    weekday_stats = stock.groupby('Weekday')['Returns'].agg([
        'mean', 'std', 'count', 'min', 'max'
    ])
    
    # Map weekday numbers to names
    weekday_names = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
    weekday_stats.index = weekday_names
    
    prompt = f"""
    Day-of-week analysis for {symbol}:
    
    {weekday_stats.round(4).to_string()}
    
    Analyze:
    1. Which days show strongest/weakest average returns
    2. Days with highest volatility  
    3. Statistical significance (sample size considerations)
    4. Practical trading implications
    5. Risk management considerations for each day
    
    Focus on actionable trading strategies.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return weekday_stats, analysis

import pandas_market_calendars as mcal

def analyze_holiday_effects(symbol, years=10):
    """Analyze trading patterns around holidays"""
    
    # Get market calendar
    nyse = mcal.get_calendar('NYSE')
    end_date = datetime.now()
    start_date = end_date - timedelta(days=years*365)
    
    # Get holiday dates
    holidays = nyse.holidays().holidays
    holiday_dates = [h for h in holidays if start_date <= h <= end_date]
    
    # Fetch stock data
    stock = yf.download(symbol, start=start_date, end=end_date)
    stock['Returns'] = stock['Close'].pct_change()
    
    # Analyze returns around holidays
    holiday_effects = []
    
    for holiday in holiday_dates:
        # Find trading days around holiday
        pre_holiday = stock.index[stock.index < holiday][-1] if len(stock.index[stock.index < holiday]) > 0 else None
        post_holiday = stock.index[stock.index > holiday][0] if len(stock.index[stock.index > holiday]) > 0 else None
        
        if pre_holiday and post_holiday:
            pre_return = stock.loc[pre_holiday, 'Returns']
            post_return = stock.loc[post_holiday, 'Returns']
            
            holiday_effects.append({
                'holiday': holiday,
                'pre_holiday_return': pre_return,
                'post_holiday_return': post_return
            })
    
    holiday_df = pd.DataFrame(holiday_effects)
    
    # Calculate aggregate statistics
    avg_pre = holiday_df['pre_holiday_return'].mean()
    avg_post = holiday_df['post_holiday_return'].mean()
    
    prompt = f"""
    Holiday trading analysis for {symbol} over {years} years:
    
    Average pre-holiday return: {avg_pre:.4f}
    Average post-holiday return: {avg_post:.4f}
    
    Sample data:
    {holiday_df.head(10).to_string()}
    
    Analyze:
    1. Pre-holiday vs post-holiday performance patterns
    2. Statistical significance of holiday effects
    3. Best holidays for trading opportunities
    4. Volume and volatility considerations
    5. Specific entry/exit strategies around holidays
    
    Provide concrete trading recommendations.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return holiday_df, analysis

def analyze_sector_seasonality():
    """Analyze seasonal performance across sectors"""
    
    # Define sector ETFs
    sectors = {
        'XLK': 'Technology',
        'XLF': 'Financial', 
        'XLE': 'Energy',
        'XLY': 'Consumer Discretionary',
        'XLP': 'Consumer Staples',
        'XLI': 'Industrial',
        'XLB': 'Materials',
        'XLU': 'Utilities',
        'XLV': 'Healthcare'
    }
    
    sector_data = {}
    
    for symbol, name in sectors.items():
        # Get 5 years of data
        end_date = datetime.now()
        start_date = end_date - timedelta(days=5*365)
        
        data = yf.download(symbol, start=start_date, end=end_date)
        data['Returns'] = data['Close'].pct_change()
        data['Month'] = data.index.month
        data['Quarter'] = data.index.quarter
        
        # Calculate quarterly performance
        quarterly_perf = data.groupby('Quarter')['Returns'].mean()
        sector_data[name] = quarterly_perf
    
    sector_df = pd.DataFrame(sector_data)
    
    prompt = f"""
    Quarterly sector performance analysis:
    
    {sector_df.round(4).to_string()}
    
    Identify:
    1. Best performing sectors by quarter
    2. Sector rotation patterns throughout the year
    3. Seasonal investment strategies
    4. Risk-adjusted sector allocation recommendations
    5. Timing for sector switches
    
    Create a seasonal sector rotation strategy.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return sector_df, analysis

class SeasonalTradingStrategy:
    def __init__(self, symbol, patterns):
        self.symbol = symbol
        self.patterns = patterns
        self.ollama = OllamaTrader()
    
    def generate_signals(self, current_date):
        """Generate trading signals based on seasonal patterns"""
        
        month = current_date.month
        weekday = current_date.weekday()
        quarter = (month - 1) // 3 + 1
        
        context = f"""
        Current date: {current_date}
        Month: {month}
        Weekday: {weekday}
        Quarter: {quarter}
        
        Historical patterns for {self.symbol}:
        {self.patterns}
        
        Based on seasonal analysis, provide:
        1. Trading signal (BUY/SELL/HOLD)
        2. Position size recommendation (% of portfolio)
        3. Entry timing strategy
        4. Risk management parameters
        5. Expected holding period
        
        Consider current seasonal context and historical performance.
        """
        
        signal = self.ollama.query_ollama(context)
        return self.parse_signal(signal)
    
    def parse_signal(self, signal_text):
        """Parse Ollama output into structured signal"""
        # Implementation depends on your signal format
        # This is a simplified example
        
        if "BUY" in signal_text.upper():
            action = "BUY"
        elif "SELL" in signal_text.upper():
            action = "SELL"
        else:
            action = "HOLD"
            
        return {
            'action': action,
            'analysis': signal_text,
            'timestamp': datetime.now()
        }

def backtest_seasonal_strategy(symbol, start_date, end_date):
    """Backtest seasonal trading strategy performance"""
    
    # Get historical data
    stock = yf.download(symbol, start=start_date, end=end_date)
    stock['Returns'] = stock['Close'].pct_change()
    
    # Simulate seasonal strategy
    portfolio_value = 10000  # Starting capital
    positions = []
    
    # Monthly rebalancing based on seasonal patterns
    monthly_dates = pd.date_range(start_date, end_date, freq='M')
    
    for date in monthly_dates:
        month = date.month
        
        # Simplified seasonal logic (you'd use Ollama analysis here)
        if month in [11, 12, 1]:  # Strong seasonal months
            position_size = 1.0  # Fully invested
        elif month in [5, 6, 9]:  # Weak seasonal months  
            position_size = 0.5  # Half invested
        else:
            position_size = 0.75  # Normal allocation
            
        positions.append({
            'date': date,
            'position_size': position_size
        })
    
    # Calculate strategy returns
    strategy_returns = []
    
    for i, pos in enumerate(positions[:-1]):
        start = pos['date']
        end = positions[i+1]['date']
        
        period_return = stock.loc[start:end, 'Returns'].sum()
        strategy_return = period_return * pos['position_size']
        strategy_returns.append(strategy_return)
    
    total_return = sum(strategy_returns)
    buy_hold_return = stock['Returns'].sum()
    
    prompt = f"""
    Seasonal strategy backtest results for {symbol}:
    
    Strategy total return: {total_return:.4f}
    Buy & hold return: {buy_hold_return:.4f}
    Outperformance: {total_return - buy_hold_return:.4f}
    
    Analyze:
    1. Strategy effectiveness vs buy-and-hold
    2. Risk-adjusted performance metrics
    3. Maximum drawdown periods
    4. Seasonal pattern validation
    5. Strategy optimization suggestions
    
    Provide concrete improvements and risk assessment.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return {
        'strategy_return': total_return,
        'benchmark_return': buy_hold_return,
        'analysis': analysis
    }

def analyze_cross_asset_seasonality():
    """Analyze seasonal patterns across multiple assets"""
    
    assets = ['SPY', 'QQQ', 'GLD', 'TLT', 'VTI']
    correlations = {}
    
    for asset in assets:
        # Get monthly returns for each asset
        data = yf.download(asset, period='10y')
        monthly_returns = data['Close'].resample('M').last().pct_change()
        monthly_returns.index = monthly_returns.index.month
        
        correlations[asset] = monthly_returns.groupby(level=0).mean()
    
    correlation_df = pd.DataFrame(correlations)
    
    prompt = f"""
    Cross-asset seasonal correlation analysis:
    
    {correlation_df.round(4).to_string()}
    
    Identify:
    1. Assets with strongest seasonal correlations
    2. Diversification opportunities by season
    3. Seasonal asset allocation strategies
    4. Hedge relationships during specific months
    5. Portfolio rebalancing calendar
    
    Create a multi-asset seasonal rotation model.
    """
    
    trader = OllamaTrader()
    analysis = trader.query_ollama(prompt)
    
    return correlation_df, analysis

def calculate_seasonal_position_size(symbol, confidence_level, volatility_data):
    """Calculate position size based on seasonal confidence and volatility"""
    
    prompt = f"""
    Position sizing for seasonal strategy:
    
    Asset: {symbol}
    Confidence in seasonal pattern: {confidence_level}
    Historical volatility data: {volatility_data}
    
    Calculate optimal position size considering:
    1. Kelly Criterion application
    2. Risk parity principles  
    3. Seasonal pattern strength
    4. Current market volatility
    5. Maximum acceptable drawdown
    
    Provide specific position size percentage and rationale.
    """
    
    trader = OllamaTrader()
    sizing_analysis = trader.query_ollama(prompt)
    
    return sizing_analysis

def create_seasonal_dashboard(strategies):
    """Create monitoring dashboard for seasonal strategies"""
    
    performance_summary = []
    
    for strategy in strategies:
        # Calculate key metrics
        returns = strategy.get_returns()
        sharpe_ratio = returns.mean() / returns.std() * np.sqrt(252)
        max_drawdown = calculate_max_drawdown(returns)
        
        performance_summary.append({
            'strategy': strategy.name,
            'total_return': returns.sum(),
            'sharpe_ratio': sharpe_ratio,
            'max_drawdown': max_drawdown
        })
    
    dashboard_data = pd.DataFrame(performance_summary)
    
    prompt = f"""
    Seasonal strategy performance dashboard:
    
    {dashboard_data.to_string()}
    
    Provide:
    1. Best performing seasonal strategies
    2. Risk-adjusted rankings
    3. Optimization recommendations
    4. Market regime considerations
    5. Portfolio allocation suggestions
    
    Focus on actionable insights for strategy improvement.
    """
    
    trader = OllamaTrader()
    dashboard_analysis = trader.query_ollama(prompt)
    
    return dashboard_data, dashboard_analysis

def calculate_max_drawdown(returns):
    """Calculate maximum drawdown from return series"""
    cumulative = (1 + returns).cumprod()
    rolling_max = cumulative.expanding().max()
    drawdown = (cumulative - rolling_max) / rolling_max
    return drawdown.min()

def clean_market_data(symbol, start_date, end_date):
    """Clean and validate market data for seasonal analysis"""
    
    data = yf.download(symbol, start=start_date, end=end_date)
    
    # Remove outliers (returns > 3 standard deviations)
    returns = data['Close'].pct_change()
    mean_return = returns.mean()
    std_return = returns.std()
    
    outlier_threshold = 3 * std_return
    cleaned_data = data[abs(returns - mean_return) <= outlier_threshold]
    
    # Handle missing data
    cleaned_data = cleaned_data.fillna(method='forward').fillna(method='backward')
    
    return cleaned_data

def validate_seasonal_patterns(returns_data, pattern_description):
    """Use Ollama to validate seasonal pattern significance"""
    
    prompt = f"""
    Statistical validation of seasonal pattern:
    
    Pattern: {pattern_description}
    Sample size: {len(returns_data)}
    Mean return: {returns_data.mean():.4f}
    Standard deviation: {returns_data.std():.4f}
    
    Assess:
    1. Statistical significance (p-value estimation)
    2. Economic significance vs statistical significance
    3. Sample size adequacy
    4. Risk of overfitting
    5. Out-of-sample testing recommendations
    
    Provide confidence level in pattern validity.
    """
    
    trader = OllamaTrader()
    validation = trader.query_ollama(prompt)
    
    return validation