from axion import Axion, visualize
import pandas as pd
import numpy as np
# Initialize the client with your API key
client = Axion(api_key="your_api_key_here")
# For this analysis, we'll focus on:
# 1. Companies with major sports sponsorships
# 2. Consumer discretionary stocks around major events
# 3. Media and broadcasting companies

def analyze_event_impact(event_date, related_tickers, window_days=30):
    """
    Analyze stock performance around major sporting events
    
    Parameters:
    - event_date: String in YYYY-MM-DD format
    - related_tickers: List of company tickers to analyze
    - window_days: Days before and after event to analyze
    """
    
    results = {}
    
    for ticker in related_tickers:
        try:
            # Get price data around the event
            prices = client.stocks.prices(
                ticker=ticker,
                from_date=(pd.to_datetime(event_date) - pd.Timedelta(days=window_days)).strftime('%Y-%m-%d'),
                to_date=(pd.to_datetime(event_date) + pd.Timedelta(days=window_days)).strftime('%Y-%m-%d'),
                frame='daily'
            )
            
            # Get news sentiment
            sentiment = client.sentiment.all(ticker=ticker)
            
            # Get company profile for fundamental context
            profile = client.profiles.summary(ticker=ticker)
            
            results[ticker] = {
                'prices': pd.DataFrame(prices),
                'sentiment': sentiment,
                'profile': profile
            }
            
        except Exception as e:
            print(f"Error fetching data for {ticker}: {e}")
    
    return results
# Example: Super Bowl 2024 related companies
super_bowl_tickers = ['NKE', 'PEP', 'BUD', 'DIS', 'CMCSA', 'UA']
event_data = analyze_event_impact('2024-02-11', super_bowl_tickers)

def visualize_event_impact(event_data, event_date):
    """
    Create comprehensive visualizations of event impact
    """
    
    all_prices = []
    
    for ticker, data in event_data.items():
        if 'prices' in data and not data['prices'].empty:
            df = data['prices'].copy()
            df['ticker'] = ticker
            df['date'] = pd.to_datetime(df['time'])
            df['normalized_close'] = df['close'] / df['close'].iloc[0]  # Normalize to event date
            
            # Mark event date
            event_dt = pd.to_datetime(event_date)
            df['days_from_event'] = (df['date'] - event_dt).dt.days
            
            all_prices.append(df)
    
    combined_df = pd.concat(all_prices)
    
    # Create visualization
    fig = visualize.graph(
        df=combined_df,
        x='days_from_event',
        lines=['normalized_close'],
        color='ticker',
        title=f'Stock Performance Around Event (Normalized)'
    )
    
    return fig
# Generate the visualization
visualize_event_impact(event_data, '2024-02-11')

def analyze_sentiment_correlation(event_data, event_date):
    """
    Correlate news sentiment with stock performance
    """
    
    correlations = {}
    
    for ticker, data in event_data.items():
        if 'prices' in data and 'sentiment' in data:
            prices_df = pd.DataFrame(data['prices'])
            sentiment_data = data['sentiment']
            
            # Convert sentiment to DataFrame if needed
            sentiment_df = pd.DataFrame(sentiment_data.get('news', []))
            
            if not sentiment_df.empty:
                # Merge on date
                prices_df['date'] = pd.to_datetime(prices_df['time']).dt.date
                sentiment_df['date'] = pd.to_datetime(sentiment_df.get('date', '')).dt.date
                
                merged = pd.merge(prices_df, sentiment_df, on='date', how='left')
                
                # Calculate correlation
                if 'sentiment_score' in merged.columns:
                    correlation = merged['close'].corr(merged['sentiment_score'])
                    correlations[ticker] = correlation
    
    # Visualize correlations
    corr_df = pd.DataFrame(list(correlations.items()), columns=['Ticker', 'Correlation'])
    visualize.bar(corr_df, x='Ticker', y='Correlation')
    
    return correlations
correlations = analyze_sentiment_correlation(event_data, '2024-02-11')

def predict_event_impact(ticker, event_date, features=['close', 'volume']):
    """
    Use LSTM to predict stock movements around events
    """
    
    # Get historical data
    prices = client.stocks.prices(
        ticker=ticker,
        from_date='2023-01-01',
        to_date='2024-03-01',
        frame='daily'
    )
    
    df = pd.DataFrame(prices)
    
    # Add event indicator
    df['date'] = pd.to_datetime(df['time'])
    df['days_to_event'] = (pd.to_datetime(event_date) - df['date']).dt.days
    df['event_indicator'] = np.where(abs(df['days_to_event']) <= 7, 1, 0)
    
    # Use LSTM for prediction
    predictions = lstm(
        df=df,
        x='time',
        target='close',
        features=['volume', 'event_indicator'],
        n_preds=14,
        scale='D'
    )
    
    # Visualize results
    visualize.line(pd.concat([df, predictions]), x='time', y='close')
    
    return predictions
# Example prediction for Nike around Super Bowl
nike_predictions = predict_event_impact('NKE', '2024-02-11')

def analyze_world_cup_impact():
    """
    Comprehensive analysis of World Cup impact on stocks
    """
    
    # Companies with World Cup sponsorships
    sponsors = ['MCD', 'COKE', 'VISA', 'ADBE', 'QCOM']
    
    # Get data for all sponsors
    sponsor_data = {}
    
    for ticker in sponsors:
        try:
            # Financial data
            prices = client.stocks.prices(
                ticker=ticker,
                from_date='2022-10-01',
                to_date='2023-02-01',
                frame='daily'
            )
            
            # ESG scores (reputation impact)
            esg = client.esg.data(ticker=ticker)
            
            # News sentiment
            news = client.news.company(ticker=ticker)
            
            sponsor_data[ticker] = {
                'prices': prices,
                'esg': esg,
                'news': news
            }
            
        except Exception as e:
            print(f"Error with {ticker}: {e}")
    
    # Create comparison visualization
    comparison_data = []
    for ticker, data in sponsor_data.items():
        if 'prices' in data:
            df = pd.DataFrame(data['prices'])
            df['ticker'] = ticker
            df['returns'] = df['close'].pct_change() * 100
            comparison_data.append(df)
    
    combined = pd.concat(comparison_data)
    
    # Heatmap of returns during World Cup period
    pivot = combined.pivot_table(
        index='time', 
        columns='ticker', 
        values='returns'
    ).iloc[-30:]  # Last 30 days of World Cup period
    
    visualize.heatmap(
        df=pivot.reset_index(),
        x='time',
        y='ticker'
    )
    
    return sponsor_data
world_cup_analysis = analyze_world_cup_impact()

# Optimal analysis window
def optimal_analysis_window(event_type):
    windows = {
        'super_bowl': {'pre': 30, 'post': 45},
        'olympics': {'pre': 90, 'post': 180},
        'world_cup': {'pre': 60, 'post': 120}
    }
    return windows.get(event_type, {'pre': 30, 'post': 30})

def comprehensive_event_analysis(ticker, event_date):
    """
    Combine multiple data sources for robust analysis
    """
    factors = {
        'prices': client.stocks.prices(ticker, ...),
        'sentiment': client.sentiment.all(ticker),
        'esg': client.esg.data(ticker),
        'news': client.news.company(ticker),
        'supply_chain': client.supply_chain.peers(ticker)
    }
    
    # Use multi-linear regression for prediction
    predictions = multiLinearRegression(
        df=pd.DataFrame(factors['prices']),
        x='time',
        target='close',
        features=['volume', 'sentiment_score', 'esg_score'],
        n_preds=30
    )
    
    return predictions

# Advanced correlation matrix for event analysis
def premium_event_analysis(event_tickers):
    all_data = []
    
    for ticker in event_tickers:
        # Get multiple data streams
        profile = client.profiles.financials(ticker)
        sentiment = client.sentiment.all(ticker)
        prices = client.stocks.prices(ticker, frame='daily')
        
        # Combine into analysis DataFrame
        combined = {
            'ticker': ticker,
            'market_cap': profile.get('marketCap'),
            'sentiment_trend': calculate_trend(sentiment),
            'volatility': calculate_volatility(prices),
            'event_beta': calculate_event_beta(ticker, event_dates)
        }
        all_data.append(combined)
    
    df = pd.DataFrame(all_data)
    visualize.cov(df)  # Correlation matrix visualization

client = Axion(api_key="your_key")
# First analysis: Super Bowl impact on your portfolio
def analyze_portfolio_event_sensitivity(portfolio_tickers, event_date):
    results = {}
    for ticker in portfolio_tickers:
        impact_score = calculate_event_impact_score(
            client, 
            ticker, 
            event_date
        )
        results[ticker] = impact_score
    
    return pd.Series(results).sort_values(ascending=False)
# Your sports finance journey starts here!