Keltner Channels Indicator

Overview

Keltner Channels are volatility-based bands that use ATR for band calculation, providing a more responsive alternative to Bollinger Bands. This implementation will leverage our existing EMA and ATR implementations for enhanced trend and volatility analysis.

Status

• Domain Model Design
• Core Implementation
• API Integration
• Testing
• Documentation

Components

1. Domain Model

interface KeltnerData {
  // Core Values
  middle_line: number; // EMA center line
  upper_band: number; // Upper Keltner band
  lower_band: number; // Lower Keltner band

  // Analysis
  position: KeltnerPosition; // Price position relative to bands
  bandwidth: number; // Current band width
  bandwidth_state: BandWidth; // Band width trend
  trend_strength: TrendStrength; // Based on EMA and ATR

  // Signals
  signal: SignalType; // Trading signal
  signal_strength: number; // Signal confidence (0-1)
}

enum KeltnerPosition {
  ABOVE_UPPER = 'above_upper',
  BELOW_LOWER = 'below_lower',
  BETWEEN_BANDS = 'between_bands',
  NEAR_UPPER = 'near_upper',
  NEAR_LOWER = 'near_lower',
}

enum BandWidth {
  EXPANDING = 'expanding',
  CONTRACTING = 'contracting',
  STABLE = 'stable',
}

2. Configuration

interface KeltnerSettings {
  ema_period: number; // EMA period (default: 20)
  atr_period: number; // ATR period (default: 10)
  atr_multiplier: number; // Band width multiplier (default: 2.0)
  near_band_threshold: number; // % distance for near band state
}

3. API Endpoints

REST API

• GET /v1/keltner
  • Parameters:
    • symbol: Trading pair
    • timeframe: Candle timeframe
    • ema_period: Optional EMA period
    • atr_period: Optional ATR period
    • atr_multiplier: Optional multiplier

WebSocket

• Channel: keltner
  • Updates: Band values and position
  • Frequency: On candle close

Technical Implementation

1. Core Calculation

def compute_keltner(
    df: pd.DataFrame,
    settings: KeltnerSettings
) -> pd.DataFrame:
    """
    Calculate Keltner Channels using EMA and ATR.

    Args:
        df: DataFrame with OHLCV data
        settings: Keltner calculation settings

    Returns:
        DataFrame with Keltner calculations
    """
    # Calculate EMA for middle line
    df['middle_line'] = df['close'].ewm(
        span=settings.ema_period,
        adjust=False
    ).mean()

    # Calculate ATR
    df['atr'] = compute_atr(df, settings.atr_period)

    # Calculate bands
    df['upper_band'] = (
        df['middle_line'] +
        (df['atr'] * settings.atr_multiplier)
    )
    df['lower_band'] = (
        df['middle_line'] -
        (df['atr'] * settings.atr_multiplier)
    )

    # Calculate bandwidth
    df['bandwidth'] = (
        (df['upper_band'] - df['lower_band']) /
        df['middle_line']
    )

    return df

2. Analysis Functions

def analyze_position(
    price: float,
    upper: float,
    lower: float,
    middle: float,
    threshold: float
) -> KeltnerPosition:
    """Determine price position relative to bands."""
    # Implementation details

def analyze_bandwidth(
    current: float,
    previous: float
) -> BandWidth:
    """Analyze band width trend."""
    # Implementation details

def generate_signal(
    position: KeltnerPosition,
    bandwidth: BandWidth,
    trend_strength: TrendStrength
) -> Tuple[SignalType, float]:
    """Generate trading signal and strength."""
    # Implementation details

3. Integration Points

• Integration with EMA analysis
• Integration with ATR volatility states
• Comparison with Bollinger Bands
• Signal combination logic

Configuration

TIMEFRAME_SETTINGS: Dict[str, KeltnerSettings] = {
    "1m": KeltnerSettings(
        ema_period=20,
        atr_period=10,
        atr_multiplier=2.0,
        near_band_threshold=0.05
    ),
    "5m": KeltnerSettings(...),
    "15m": KeltnerSettings(...),
    "1h": KeltnerSettings(...),
    "4h": KeltnerSettings(...),
    "1d": KeltnerSettings(...)
}

Development Guidelines

1. Performance Optimization

• Reuse EMA calculations
• Reuse ATR calculations
• Optimize band calculations
• Efficient signal generation

2. Testing Strategy

def test_keltner_calculation():
    """Test basic Keltner Channel calculation."""

def test_band_width():
    """Test band width calculation and states."""

def test_position_analysis():
    """Test price position classification."""

def test_signal_generation():
    """Test trading signal generation."""

def test_integration():
    """Test integration with EMA and ATR."""

3. Error Handling

• Handle missing data
• Validate parameters
• Handle calculation edge cases
• Manage real-time updates

Dependencies

• NumPy: Numerical operations
• Pandas: Data manipulation
• FastAPI: REST endpoints
• Existing EMA and ATR implementations

Future Enhancements

1. Dynamic multiplier adjustment
2. Multi-timeframe analysis
3. Band compression alerts
4. Machine learning optimization

References

1. Keltner Channels
2. ATR Indicators
3. Volatility Indicators