Support and Resistance: Algorithmic Detection

import yfinance as yf
import pandas as pd
import numpy as np

def find_swing_highs_lows(df, window=5):
    """Find swing highs and lows."""
    swing_highs = []
    swing_lows = []

    for i in range(window, len(df) - window):
        # Swing high
        if df['High'].iloc[i] == df['High'].iloc[i-window:i+window+1].max():
            swing_highs.append({'Date': df.index[i], 'Price': df['High'].iloc[i]})

        # Swing low
        if df['Low'].iloc[i] == df['Low'].iloc[i-window:i+window+1].min():
            swing_lows.append({'Date': df.index[i], 'Price': df['Low'].iloc[i]})

    return pd.DataFrame(swing_highs), pd.DataFrame(swing_lows)

# Download data
df = yf.download('AAPL', period='6mo', progress=False)

# Find swings
highs_df, lows_df = find_swing_highs_lows(df, window=5)

print(f"Detected {len(highs_df)} swing highs and {len(lows_df)} swing lows")

print("\nRecent Swing Highs (Resistance):")
print(highs_df.tail(10))

print("\nRecent Swing Lows (Support):")
print(lows_df.tail(10))

def cluster_levels(prices, tolerance_pct=2.0):
    """
    Cluster nearby price levels into zones.

    Args:
        prices: List of prices
        tolerance_pct: % tolerance for clustering

    Returns:
        List of clustered zones with strength (touch count)
    """
    if len(prices) == 0:
        return []

    prices_sorted = sorted(prices)
    clusters = []
    current_cluster = [prices_sorted[0]]

    for price in prices_sorted[1:]:
        # Check if price is within tolerance of cluster mean
        cluster_mean = np.mean(current_cluster)
        if abs(price - cluster_mean) / cluster_mean * 100 <= tolerance_pct:
            current_cluster.append(price)
        else:
            # Save current cluster and start new one
            clusters.append({
                'level': np.mean(current_cluster),
                'touches': len(current_cluster),
                'min': min(current_cluster),
                'max': max(current_cluster)
            })
            current_cluster = [price]

    # Add last cluster
    if current_cluster:
        clusters.append({
            'level': np.mean(current_cluster),
            'touches': len(current_cluster),
            'min': min(current_cluster),
            'max': max(current_cluster)
        })

    return clusters

# Cluster resistance levels
resistance_prices = highs_df['Price'].tolist()
resistance_zones = cluster_levels(resistance_prices, tolerance_pct=2.0)

print("Resistance Zones (clustered):")
for i, zone in enumerate(resistance_zones, 1):
    print(f"{i}. ${zone['level']:.2f} (touches: {zone['touches']}, "
          f"range: ${zone['min']:.2f}-${zone['max']:.2f})")

# Cluster support levels
support_prices = lows_df['Price'].tolist()
support_zones = cluster_levels(support_prices, tolerance_pct=2.0)

print("\nSupport Zones (clustered):")
for i, zone in enumerate(support_zones, 1):
    print(f"{i}. ${zone['level']:.2f} (touches: {zone['touches']}, "
          f"range: ${zone['min']:.2f}-${zone['max']:.2f})")

def test_level_bounce(df, level, tolerance_pct=1.0, lookforward=5):
    """
    Test how often price bounces at a level.

    Args:
        level: Price level to test
        tolerance_pct: % distance to consider "at level"
        lookforward: Bars to check for bounce

    Returns:
        dict with bounce statistics
    """
    touches = 0
    bounces = 0

    for i in range(len(df) - lookforward):
        low = df['Low'].iloc[i]
        high = df['High'].iloc[i]

        # Check if price touched the level
        level_low = level * (1 - tolerance_pct / 100)
        level_high = level * (1 + tolerance_pct / 100)

        if low <= level_high and high >= level_low:
            touches += 1

            # Check if price bounced (moved away from level)
            future_prices = df['Close'].iloc[i+1:i+lookforward+1]
            if level >= df['Close'].iloc[i]:  # Testing support
                if (future_prices > level * 1.01).any():  # Bounced up 1%
                    bounces += 1
            else:  # Testing resistance
                if (future_prices < level * 0.99).any():  # Bounced down 1%
                    bounces += 1

    bounce_rate = bounces / touches * 100 if touches > 0 else 0

    return {
        'level': level,
        'touches': touches,
        'bounces': bounces,
        'bounce_rate': bounce_rate
    }

# Test strongest support zone
strong_support = support_zones[2]['level']  # $190.01
support_test = test_level_bounce(df, strong_support, tolerance_pct=1.5, lookforward=5)

print("Support Level Test Results:")
print(f"Level: ${support_test['level']:.2f}")
print(f"Touches: {support_test['touches']}")
print(f"Bounces: {support_test['bounces']}")
print(f"Bounce Rate: {support_test['bounce_rate']:.1f}%")

# Test strongest resistance zone
strong_resistance = resistance_zones[1]['level']  # $194.61
resistance_test = test_level_bounce(df, strong_resistance, tolerance_pct=1.5, lookforward=5)

print("\nResistance Level Test Results:")
print(f"Level: ${resistance_test['level']:.2f}")
print(f"Touches: {resistance_test['touches']}")
print(f"Bounces: {resistance_test['bounces']}")
print(f"Bounce Rate: {resistance_test['bounce_rate']:.1f}%")

# Calculate moving averages
df['SMA_50'] = df['Close'].rolling(50).mean()
df['SMA_200'] = df['Close'].rolling(200).mean()
df['EMA_20'] = df['Close'].ewm(span=20).mean()

# Test if price bounces off MAs
def test_ma_support_resistance(df, ma_column, tolerance_pct=1.0):
    """Test how often price bounces at moving average."""
    touches = 0
    bounces = 0

    for i in range(50, len(df) - 5):  # Skip first 50 for MA stability
        if pd.isna(df[ma_column].iloc[i]):
            continue

        ma_level = df[ma_column].iloc[i]
        low = df['Low'].iloc[i]
        high = df['High'].iloc[i]

        # Check if price touched MA
        if abs(low - ma_level) / ma_level * 100 < tolerance_pct or            abs(high - ma_level) / ma_level * 100 < tolerance_pct:
            touches += 1

            # Check bounce
            future_close = df['Close'].iloc[i+1:i+6]
            if df['Close'].iloc[i] < ma_level:  # Below MA (testing support)
                if (future_close > ma_level * 1.01).any():
                    bounces += 1
            else:  # Above MA (testing resistance)
                if (future_close < ma_level * 0.99).any():
                    bounces += 1

    return touches, bounces, bounces/touches*100 if touches > 0 else 0

# Test different MAs
ma_tests = {}
for ma_name in ['SMA_50', 'SMA_200', 'EMA_20']:
    touches, bounces, rate = test_ma_support_resistance(df, ma_name, tolerance_pct=1.5)
    ma_tests[ma_name] = {'touches': touches, 'bounces': bounces, 'rate': rate}

print("Moving Average Support/Resistance Test:")
print(f"{'MA':<12} {'Touches':>8} {'Bounces':>8} {'Rate':>8}")
print("-" * 40)
for ma, stats in ma_tests.items():
    print(f"{ma:<12} {stats['touches']:>8} {stats['bounces']:>8} {stats['rate']:>7.1f}%")

def find_round_numbers(price_range, increment=10):
    """Generate round number levels in price range."""
    min_price = int(price_range[0] / increment) * increment
    max_price = int(price_range[1] / increment) * increment + increment
    return list(range(min_price, max_price, increment))

# Find round numbers in AAPL's range
price_range = (df['Low'].min(), df['High'].max())
round_levels = find_round_numbers(price_range, increment=10)

print(f"Testing round number levels: {round_levels}")

# Test each round level
round_results = []
for level in round_levels:
    result = test_level_bounce(df, level, tolerance_pct=1.0, lookforward=5)
    if result['touches'] > 0:
        round_results.append(result)

print("\nRound Number Support/Resistance:")
print(f"{'Level':<10} {'Touches':>8} {'Bounces':>8} {'Rate':>8}")
print("-" * 38)
for r in sorted(round_results, key=lambda x: x['level']):
    print(f"${r['level']:<9.0f} {r['touches']:>8} {r['bounces']:>8} {r['bounce_rate']:>7.1f}%")