from axion import Axion, visualize
import pandas as pd
# Initialize the Axion client
client = Axion(api_key="your_api_key_here")

# Get Apple's suppliers
suppliers = client.supply_chain.suppliers("AAPL")
suppliers_df = pd.DataFrame(suppliers)
# Get Apple's customers (if available)
customers = client.supply_chain.customers("AAPL")
customers_df = pd.DataFrame(customers)
# Get industry peers
peers = client.supply_chain.peers("AAPL")
peers_df = pd.DataFrame(peers)
# Display the supply chain network
print("Apple's Key Supply Chain Relationships:")
print(f"Suppliers: {len(suppliers_df)} companies")
print(f"Customers: {len(customers_df)} companies")
print(f"Peers: {len(peers_df)} companies")

def get_price_history(ticker, days_back=365):
    """Fetch historical price data for a given ticker"""
    prices = client.stocks.prices(
        ticker=ticker,
        from_date=pd.Timestamp.now() - pd.Timedelta(days=days_back),
        to_date=pd.Timestamp.now(),
        frame='daily'
    )
    return pd.DataFrame(prices)
# Get Apple's price history
aapl_prices = get_price_history("AAPL")
# Get price history for key suppliers (example: TSMC, QCOM, AVGO)
supplier_tickers = ["TSM", "QCOM", "AVGO", "SWKS", "CRUS"]
supplier_prices = {}
for ticker in supplier_tickers:
    try:
        supplier_prices[ticker] = get_price_history(ticker)
        print(f"Retrieved data for {ticker}")
    except Exception as e:
        print(f"Could not retrieve {ticker}: {e}")

# Combine all price data into a single DataFrame
combined_data = aapl_prices[['time', 'close']].rename(columns={'close': 'AAPL'})
for ticker, prices in supplier_prices.items():
    combined_data = pd.merge(
        combined_data,
        prices[['time', 'close']].rename(columns={'close': ticker}),
        on='time',
        how='inner'
    )
# Calculate beta for each supplier relative to Apple
beta_results = []
for supplier in supplier_tickers:
    if supplier in combined_data.columns:
        # Use the beta function from Axion SDK
        beta_value = beta(combined_data, 'AAPL', supplier)
        beta_results.append({
            'Supplier': supplier,
            'Beta_vs_AAPL': beta_value,
            'Relationship': 'Strong' if abs(beta_value) > 0.7 else 'Moderate' if abs(beta_value) > 0.3 else 'Weak'
        })
beta_df = pd.DataFrame(beta_results)
print("\nBeta Analysis Results:")
print(beta_df.sort_values('Beta_vs_AAPL', ascending=False))

# Create correlation matrix
correlation_matrix = combined_data.drop('time', axis=1).corr()
# Visualize the correlation matrix
visualize.cov(correlation_matrix)
# Perform linear regression to predict Apple's price from supplier prices
from axion import multiLinearRegression
# Prepare data for multivariate analysis
analysis_df = combined_data.copy()
analysis_df['time'] = pd.to_datetime(analysis_df['time'])
# Run multivariate regression
prediction = multiLinearRegression(
    df=analysis_df,
    x='time',
    target='AAPL',
    features=supplier_tickers,
    n_preds=30,
    scale='D'
)
print("\nMultivariate Analysis Results:")
print(f"Predicted Apple price movements based on {len(supplier_tickers)} suppliers")

# Create a network visualization of beta relationships
import plotly.graph_objects as go
# Prepare data for network graph
nodes = ['AAPL'] + supplier_tickers
node_x = []
node_y = []
node_colors = []
node_sizes = []
# Position Apple at center
node_x.append(0)
node_y.append(0)
node_colors.append('blue')
node_sizes.append(20)
# Position suppliers in a circle around Apple
import math
for i, supplier in enumerate(supplier_tickers):
    angle = 2 * math.pi * i / len(supplier_tickers)
    radius = 2
    node_x.append(radius * math.cos(angle))
    node_y.append(radius * math.sin(angle))
    
    # Color by beta value
    beta_val = beta_df[beta_df['Supplier'] == supplier]['Beta_vs_AAPL'].values[0]
    if beta_val > 0.5:
        node_colors.append('green')  # Strong positive correlation
    elif beta_val < -0.5:
        node_colors.append('red')    # Strong negative correlation
    else:
        node_colors.append('yellow') # Weak correlation
    
    node_sizes.append(15 + abs(beta_val) * 10)
# Create edges
edge_x = []
edge_y = []
edge_colors = []
for i, supplier in enumerate(supplier_tickers):
    beta_val = beta_df[beta_df['Supplier'] == supplier]['Beta_vs_AAPL'].values[0]
    
    # Add edge from Apple to supplier
    edge_x.extend([0, node_x[i+1], None])
    edge_y.extend([0, node_y[i+1], None])
    
    # Color edge by beta strength
    if abs(beta_val) > 0.7:
        edge_colors.append('rgba(0, 255, 0, 0.8)')
    elif abs(beta_val) > 0.3:
        edge_colors.append('rgba(255, 255, 0, 0.6)')
    else:
        edge_colors.append('rgba(255, 0, 0, 0.4)')
# Create the network graph
fig = go.Figure()
# Add edges
for i in range(0, len(edge_x)-1, 3):
    fig.add_trace(go.Scatter(
        x=edge_x[i:i+3],
        y=edge_y[i:i+3],
        mode='lines',
        line=dict(width=2, color=edge_colors[i//3]),
        hoverinfo='none'
    ))
# Add nodes
fig.add_trace(go.Scatter(
    x=node_x,
    y=node_y,
    mode='markers+text',
    marker=dict(
        size=node_sizes,
        color=node_colors,
        line=dict(width=2, color='DarkSlateGrey')
    ),
    text=nodes,
    textposition="top center",
    hoverinfo='text'
))
fig.update_layout(
    title='Supply Chain Beta Relationships: Apple and Key Suppliers',
    showlegend=False,
    hovermode='closest',
    margin=dict(b=20,l=5,r=5,t=40),
    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
)
visualize(fig)

# Identify high-beta suppliers that could amplify Apple's risk
high_risk_suppliers = beta_df[beta_df['Beta_vs_AAPL'] > 0.8]
print(f"High-risk suppliers (Beta > 0.8): {len(high_risk_suppliers)}")
print("Consider diversifying away from these high-correlation suppliers")

# Check if supplier prices lead Apple's price movements
def calculate_lead_lag_correlation(lead_ticker, lag_ticker, lag_days=5):
    lead_prices = get_price_history(lead_ticker)
    lag_prices = get_price_history(lag_ticker)
    
    # Shift the leading ticker's prices
    lead_prices['close_shifted'] = lead_prices['close'].shift(-lag_days)
    
    # Merge and calculate correlation
    merged = pd.merge(
        lead_prices[['time', 'close_shifted']],
        lag_prices[['time', 'close']],
        on='time'
    ).dropna()
    
    correlation = merged['close_shifted'].corr(merged['close'])
    return correlation
# Test if TSMC leads Apple
lead_corr = calculate_lead_lag_correlation("TSM", "AAPL", lag_days=3)
print(f"TSMC 3-day lead correlation with AAPL: {lead_corr:.3f}")

# Build a diversified portfolio across the supply chain
def build_supply_chain_portfolio(anchor_ticker, max_beta=0.5):
    """Select companies from the same supply chain with low mutual beta"""
    suppliers = client.supply_chain.suppliers(anchor_ticker)
    supplier_tickers = [s['ticker'] for s in suppliers[:10]]  # Top 10 suppliers
    
    portfolio = [anchor_ticker]
    
    for ticker in supplier_tickers:
        try:
            prices = get_price_history(ticker)
            if len(prices) > 0:
                # Calculate beta relative to existing portfolio
                max_existing_beta = 0
                for existing in portfolio:
                    combined = pd.merge(
                        get_price_history(existing)[['time', 'close']].rename(columns={'close': existing}),
                        prices[['time', 'close']].rename(columns={'close': ticker}),
                        on='time'
                    )
                    if len(combined) > 10:  # Minimum data points
                        beta_val = beta(combined, existing, ticker)
                        max_existing_beta = max(max_existing_beta, abs(beta_val))
                
                if max_existing_beta <= max_beta:
                    portfolio.append(ticker)
                    print(f"Added {ticker} to portfolio (max beta: {max_existing_beta:.3f})")
        except:
            continue
    
    return portfolio
diversified_portfolio = build_supply_chain_portfolio("AAPL", max_beta=0.3)
print(f"Diversified supply chain portfolio: {diversified_portfolio}")

from axion import lstm
# Use LSTM to predict Apple's price based on supplier patterns
lstm_predictions = lstm(
    df=analysis_df,
    x='time',
    target='AAPL',
    features=supplier_tickers,
    n_preds=30,
    scale='D'
)
print("LSTM predictions for next 30 days:")
visualize.line(lstm_predictions, x='time', y='AAPL')

# Quick start template for your own analysis
def analyze_supply_chain_beta(company_ticker):
    """Complete supply chain beta analysis for any company"""
    
    # Initialize client
    client = Axion(api_key="your_api_key_here")
    
    # Get supply chain data
    suppliers = client.supply_chain.suppliers(company_ticker)
    supplier_tickers = [s['ticker'] for s in suppliers[:15]]
    
    # Get price data
    company_prices = get_price_history(company_ticker)
    
    # Calculate beta for each relationship
    results = []
    for supplier in supplier_tickers:
        try:
            supplier_prices = get_price_history(supplier)
            # Calculate beta and store results
            # ... (full implementation)
        except:
            continue
    
    return pd.DataFrame(results)
# Run your analysis
results = analyze_supply_chain_beta("MSFT")  # Try with Microsoft
print(results)