Technical Analysis & Indicators

# Fetch data for technical analysis
def get_stock_data_for_ta(symbol, period="1y", interval="1d"):
    """
    Fetch and prepare stock data for technical analysis
    """
    print(f"Fetching {symbol} data for technical analysis...")
    
    # Get stock data
    stock = yf.Ticker(symbol)
    data = stock.history(period=period, interval=interval)
    
    if data.empty:
        print(f"❌ No data available for {symbol}")
        return None
    
    # Add basic calculated columns
    data['Price_Change'] = data['Close'] - data['Open']
    data['Price_Change_Pct'] = (data['Close'] - data['Open']) / data['Open'] * 100
    data['High_Low_Pct'] = (data['High'] - data['Low']) / data['Low'] * 100
    
    # Add day classification
    data['Green_Day'] = data['Close'] > data['Open']
    data['Red_Day'] = data['Close'] < data['Open']
    
    print(f"✅ Successfully fetched {len(data)} days of data")
    print(f"Date range: {data.index[0].date()} to {data.index[-1].date()}")
    
    return data

# Get Apple stock data for analysis
symbol = "AAPL"
aapl_data = get_stock_data_for_ta(symbol, period="1y")

# Display basic information
print(f"\n=== {symbol} Basic Statistics ===")
print(f"Current Price: ${aapl_data['Close'].iloc[-1]:.2f}")
print(f"52-Week High: ${aapl_data['High'].max():.2f}")
print(f"52-Week Low: ${aapl_data['Low'].min():.2f}")
print(f"Average Volume: {aapl_data['Volume'].mean():,.0f}")
print(f"Green Days: {aapl_data['Green_Day'].sum()} ({aapl_data['Green_Day'].mean()*100:.1f}%)")
print(f"Red Days: {aapl_data['Red_Day'].sum()} ({aapl_data['Red_Day'].mean()*100:.1f}%)")

# Show recent data
print(f"\n=== Recent {symbol} Data ===")
print(aapl_data[['Open', 'High', 'Low', 'Close', 'Volume', 'Price_Change_Pct']].tail())

# Calculate moving averages
def calculate_moving_averages(data):
    """Calculate various moving averages"""
    
    # Simple Moving Averages
    data['SMA_20'] = data['Close'].rolling(window=20).mean()
    data['SMA_50'] = data['Close'].rolling(window=50).mean()
    data['SMA_200'] = data['Close'].rolling(window=200).mean()
    
    # Exponential Moving Averages
    data['EMA_12'] = data['Close'].ewm(span=12).mean()
    data['EMA_26'] = data['Close'].ewm(span=26).mean()
    data['EMA_50'] = data['Close'].ewm(span=50).mean()
    
    # Moving average signals
    data['SMA_Signal'] = np.where(data['Close'] > data['SMA_20'], 1, 
                                 np.where(data['Close'] < data['SMA_20'], -1, 0))
    
    # Golden Cross and Death Cross
    data['Golden_Cross'] = (data['SMA_50'] > data['SMA_200']) & (data['SMA_50'].shift(1) <= data['SMA_200'].shift(1))
    data['Death_Cross'] = (data['SMA_50'] < data['SMA_200']) & (data['SMA_50'].shift(1) >= data['SMA_200'].shift(1))
    
    return data

# Calculate moving averages for Apple
aapl_data = calculate_moving_averages(aapl_data)

# Plot moving averages
def plot_moving_averages(data, symbol, days=180):
    """Plot price with moving averages"""
    
    recent_data = data.tail(days)
    
    fig = go.Figure()
    
    # Candlestick chart
    fig.add_trace(go.Candlestick(
        x=recent_data.index,
        open=recent_data['Open'],
        high=recent_data['High'],
        low=recent_data['Low'],
        close=recent_data['Close'],
        name='Price'
    ))
    
    # Moving averages
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['SMA_20'],
        line=dict(color='blue', width=2), name='SMA 20'
    ))
    
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['SMA_50'],
        line=dict(color='orange', width=2), name='SMA 50'
    ))
    
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['SMA_200'],
        line=dict(color='red', width=2), name='SMA 200'
    ))
    
    # Highlight golden/death crosses
    golden_crosses = recent_data[recent_data['Golden_Cross']]
    death_crosses = recent_data[recent_data['Death_Cross']]
    
    if not golden_crosses.empty:
        fig.add_trace(go.Scatter(
            x=golden_crosses.index, y=golden_crosses['Close'],
            mode='markers', marker=dict(size=10, color='gold', symbol='triangle-up'),
            name='Golden Cross'
        ))
    
    if not death_crosses.empty:
        fig.add_trace(go.Scatter(
            x=death_crosses.index, y=death_crosses['Close'],
            mode='markers', marker=dict(size=10, color='black', symbol='triangle-down'),
            name='Death Cross'
        ))
    
    fig.update_layout(
        title=f'{symbol} Price with Moving Averages',
        yaxis_title='Price ($)',
        xaxis_title='Date',
        height=600,
        xaxis_rangeslider_visible=False
    )
    
    fig.show()

# Plot moving averages
print("Creating moving averages chart...")
plot_moving_averages(aapl_data, symbol)

# Analyze moving average signals
current_price = aapl_data['Close'].iloc[-1]
sma_20 = aapl_data['SMA_20'].iloc[-1]
sma_50 = aapl_data['SMA_50'].iloc[-1]
sma_200 = aapl_data['SMA_200'].iloc[-1]

print(f"\n=== Moving Average Analysis for {symbol} ===")
print(f"Current Price: ${current_price:.2f}")
print(f"SMA 20: ${sma_20:.2f} ({'Above' if current_price > sma_20 else 'Below'})")
print(f"SMA 50: ${sma_50:.2f} ({'Above' if current_price > sma_50 else 'Below'})")
print(f"SMA 200: ${sma_200:.2f} ({'Above' if current_price > sma_200 else 'Below'})")

# Trend analysis
if sma_20 > sma_50 > sma_200:
    trend = "Strong Uptrend"
elif sma_20 < sma_50 < sma_200:
    trend = "Strong Downtrend"
elif sma_20 > sma_50:
    trend = "Short-term Uptrend"
elif sma_20 < sma_50:
    trend = "Short-term Downtrend"
else:
    trend = "Sideways/Consolidation"

print(f"Overall Trend: {trend}")

# Recent signals
recent_golden = aapl_data['Golden_Cross'].tail(30).sum()
recent_death = aapl_data['Death_Cross'].tail(30).sum()

print(f"Golden Crosses (last 30 days): {recent_golden}")
print(f"Death Crosses (last 30 days): {recent_death}")

# Volume analysis functions
def calculate_volume_indicators(data):
    """Calculate volume-based indicators"""
    
    # Volume Moving Average
    data['Volume_MA_20'] = data['Volume'].rolling(window=20).mean()
    
    # On-Balance Volume (OBV)
    data['OBV'] = (np.sign(data['Close'].diff()) * data['Volume']).fillna(0).cumsum()
    
    # Volume Rate of Change
    data['Volume_ROC'] = data['Volume'].pct_change(periods=10) * 100
    
    # Price Volume Trend (PVT)
    data['PVT'] = ((data['Close'].diff() / data['Close'].shift(1)) * data['Volume']).fillna(0).cumsum()
    
    # Volume signals
    data['High_Volume'] = data['Volume'] > data['Volume_MA_20'] * 1.5
    data['Low_Volume'] = data['Volume'] < data['Volume_MA_20'] * 0.5
    
    return data

# Calculate volume indicators
aapl_data = calculate_volume_indicators(aapl_data)

# Volume breakout analysis
def analyze_volume_breakouts(data, symbol):
    """Analyze volume breakouts and their significance"""
    
    print(f"=== Volume Analysis for {symbol} ===")
    
    # Recent high volume days
    recent_high_volume = data[data['High_Volume']].tail(10)
    
    print(f"Recent high volume days: {len(recent_high_volume)}")
    
    if not recent_high_volume.empty:
        print("\nRecent high volume sessions:")
        for date, row in recent_high_volume.iterrows():
            price_change = row['Price_Change_Pct']
            volume_multiple = row['Volume'] / row['Volume_MA_20']
            print(f"  {date.date()}: {price_change:+.2f}% price change, {volume_multiple:.1f}x average volume")
    
    # Volume-price correlation
    correlation = data['Volume'].corr(data['Price_Change_Pct'].abs())
    print(f"\nVolume-Price Change Correlation: {correlation:.3f}")
    
    # OBV trend analysis
    obv_trend = "Up" if data['OBV'].iloc[-1] > data['OBV'].iloc[-20] else "Down"
    print(f"OBV Trend (20 days): {obv_trend}")
    
    return recent_high_volume

# Analyze volume
high_volume_days = analyze_volume_breakouts(aapl_data, symbol)

# Plot volume analysis
def plot_volume_analysis(data, symbol, days=90):
    """Plot volume analysis charts"""
    
    recent_data = data.tail(days)
    
    fig = make_subplots(
        rows=3, cols=1,
        subplot_titles=(f'{symbol} Price & Volume', 'On-Balance Volume (OBV)', 'Volume Rate of Change'),
        vertical_spacing=0.1,
        row_heights=[0.5, 0.25, 0.25]
    )
    
    # Price and Volume
    fig.add_trace(go.Candlestick(
        x=recent_data.index,
        open=recent_data['Open'],
        high=recent_data['High'],
        low=recent_data['Low'],
        close=recent_data['Close'],
        name='Price',
        yaxis='y'
    ), row=1, col=1)
    
    # Volume bars (colored by price direction)
    colors = ['red' if close < open else 'green' 
              for close, open in zip(recent_data['Close'], recent_data['Open'])]
    
    fig.add_trace(go.Bar(
        x=recent_data.index,
        y=recent_data['Volume'],
        name='Volume',
        marker_color=colors,
        yaxis='y2',
        opacity=0.7
    ), row=1, col=1)
    
    # Volume MA
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['Volume_MA_20'],
        line=dict(color='blue', width=2), name='Volume MA 20',
        yaxis='y2'
    ), row=1, col=1)
    
    # OBV
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['OBV'],
        line=dict(color='purple', width=2), name='OBV'
    ), row=2, col=1)
    
    # Volume ROC
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['Volume_ROC'],
        line=dict(color='orange', width=2), name='Volume ROC'
    ), row=3, col=1)
    
    fig.add_hline(y=0, line_dash="dash", line_color="gray", opacity=0.5, row=3, col=1)
    
    # Update layout
    fig.update_layout(
        title=f'{symbol} Volume Analysis',
        height=800,
        xaxis_rangeslider_visible=False,
        showlegend=False,
        yaxis=dict(domain=[0.4, 1.0]),
        yaxis2=dict(domain=[0.4, 1.0], overlaying='y', side='right')
    )
    
    fig.show()

# Create volume analysis chart
print("Creating volume analysis dashboard...")
plot_volume_analysis(aapl_data, symbol)

# Support and Resistance Analysis
def find_support_resistance_levels(data, window=20, min_touches=2):
    """
    Find support and resistance levels using pivot points
    """
    # Calculate pivot points
    pivots_high = data['High'][(data['High'].shift(1) < data['High']) & 
                              (data['High'].shift(-1) < data['High'])]
    pivots_low = data['Low'][(data['Low'].shift(1) > data['Low']) & 
                            (data['Low'].shift(-1) > data['Low'])]
    
    # Group similar levels
    def group_levels(levels, tolerance=0.02):
        """Group price levels that are within tolerance of each other"""
        if len(levels) == 0:
            return []
        
        levels_sorted = sorted(levels)
        groups = []
        current_group = [levels_sorted[0]]
        
        for level in levels_sorted[1:]:
            if abs(level - current_group[-1]) / current_group[-1] <= tolerance:
                current_group.append(level)
            else:
                if len(current_group) >= min_touches:
                    groups.append(np.mean(current_group))
                current_group = [level]
        
        if len(current_group) >= min_touches:
            groups.append(np.mean(current_group))
        
        return groups
    
    # Find significant levels
    resistance_levels = group_levels(pivots_high.tolist())
    support_levels = group_levels(pivots_low.tolist())
    
    return support_levels, resistance_levels

# Calculate Bollinger Bands
def calculate_bollinger_bands(data, period=20, std_dev=2):
    """Calculate Bollinger Bands"""
    sma = data['Close'].rolling(window=period).mean()
    std = data['Close'].rolling(window=period).std()
    
    upper_band = sma + (std * std_dev)
    lower_band = sma - (std * std_dev)
    
    # Band squeeze indicator
    band_width = (upper_band - lower_band) / sma
    squeeze = band_width < band_width.rolling(window=20).mean() * 0.8
    
    return upper_band, sma, lower_band, squeeze

# Apply support/resistance analysis
print("Analyzing support and resistance levels...")

support_levels, resistance_levels = find_support_resistance_levels(aapl_data)
aapl_data['BB_Upper'], aapl_data['BB_Middle'], aapl_data['BB_Lower'], aapl_data['BB_Squeeze'] = calculate_bollinger_bands(aapl_data)

print(f"Found {len(support_levels)} support levels")
print(f"Found {len(resistance_levels)} resistance levels")

# Current price analysis vs levels
current_price = aapl_data['Close'].iloc[-1]
print(f"\nCurrent price: ${current_price:.2f}")

# Find nearest support and resistance
if support_levels:
    nearest_support = max([level for level in support_levels if level < current_price], default=None)
    if nearest_support:
        support_distance = (current_price - nearest_support) / current_price * 100
        print(f"Nearest support: ${nearest_support:.2f} ({support_distance:.1f}% below)")

if resistance_levels:
    nearest_resistance = min([level for level in resistance_levels if level > current_price], default=None)
    if nearest_resistance:
        resistance_distance = (nearest_resistance - current_price) / current_price * 100
        print(f"Nearest resistance: ${nearest_resistance:.2f} ({resistance_distance:.1f}% above)")

# Plot support and resistance
def plot_support_resistance(data, symbol, support_levels, resistance_levels, days=180):
    """Plot support and resistance levels"""
    
    recent_data = data.tail(days)
    
    fig = go.Figure()
    
    # Candlestick chart
    fig.add_trace(go.Candlestick(
        x=recent_data.index,
        open=recent_data['Open'],
        high=recent_data['High'],
        low=recent_data['Low'],
        close=recent_data['Close'],
        name='Price'
    ))
    
    # Bollinger Bands
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['BB_Upper'],
        line=dict(color='gray', width=1, dash='dash'),
        name='BB Upper'
    ))
    
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['BB_Middle'],
        line=dict(color='blue', width=1),
        name='BB Middle'
    ))
    
    fig.add_trace(go.Scatter(
        x=recent_data.index, y=recent_data['BB_Lower'],
        line=dict(color='gray', width=1, dash='dash'),
        name='BB Lower',
        fill='tonexty', fillcolor='rgba(173,216,230,0.2)'
    ))
    
    # Add support levels
    for level in support_levels:
        if recent_data['Low'].min() <= level <= recent_data['High'].max():
            fig.add_hline(y=level, line_dash="solid", line_color="green", 
                         opacity=0.7, annotation_text=f"Support: ${level:.2f}")
    
    # Add resistance levels
    for level in resistance_levels:
        if recent_data['Low'].min() <= level <= recent_data['High'].max():
            fig.add_hline(y=level, line_dash="solid", line_color="red", 
                         opacity=0.7, annotation_text=f"Resistance: ${level:.2f}")
    
    fig.update_layout(
        title=f'{symbol} Support & Resistance Analysis',
        yaxis_title='Price ($)',
        height=600,
        xaxis_rangeslider_visible=False,
        showlegend=False
    )
    
    fig.show()

# Create support/resistance chart
print("Creating support and resistance chart...")
plot_support_resistance(aapl_data, symbol, support_levels, resistance_levels)