Volume Profile Indicator

# indicators/volume_profile.py
 
import pandas as pd
from marketprofile import MarketProfile
 
def calculate_volume_profile(
    df: pd.DataFrame,
    row_count: int = 24,
    value_area_pct: float = 0.70
) -> dict:
    """
    Calculate Volume Profile.
 
    Args:
        df: DataFrame with OHLCV data
        row_count: Number of price bins
        value_area_pct: Percentage for value area (default 70%)
 
    Returns:
        Dictionary with POC, VAH, VAL, and volume distribution
    """
    # Create MarketProfile instance
    mp = MarketProfile(df)
    profile = mp.volume_profile
 
    # Calculate POC (highest volume price)
    poc = profile.idxmax()
 
    # Calculate Value Area (70% of volume)
    total_volume = profile.sum()
    target_volume = total_volume * value_area_pct
 
    # Find VAH and VAL
    sorted_profile = profile.sort_values(ascending=False)
    cumsum = 0
    va_prices = []
 
    for price, volume in sorted_profile.items():
        cumsum += volume
        va_prices.append(price)
        if cumsum >= target_volume:
            break
 
    vah = max(va_prices)
    val = min(va_prices)
 
    return {
        'poc': poc,
        'vah': vah,
        'val': val,
        'profile': profile
    }

Volume Profile
                                          │
                    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓ ← HVN │ Strong S/R
                    ▓▓▓▓▓▓▓▓             │
VAH ─────────────── ▓▓▓▓▓▓▓▓▓▓▓          │
                    ▓▓▓▓▓▓▓▓▓▓▓▓▓        │
                    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ ← POC (Highest Volume)
                    ▓▓▓▓▓▓▓▓▓▓▓▓▓        │
                    ▓▓                   │ ← LVN (Avoid entries here)
                    ▓▓▓                  │
VAL ─────────────── ▓▓▓▓▓▓▓▓             │
                    ▓▓▓▓▓▓▓▓▓▓▓▓▓ ← HVN  │ Strong S/R
                                          │

def check_vp_confluence(price: float, vp_data: dict, tolerance: float = 0.001) -> dict:
    """Check if price is near a Volume Profile level."""
 
    poc = vp_data['poc']
    vah = vp_data['vah']
    val = vp_data['val']
 
    # Check proximity to key levels
    if abs(price - poc) / poc < tolerance:
        return {'level': 'POC', 'type': 'equilibrium', 'price': poc}
    elif abs(price - vah) / vah < tolerance:
        return {'level': 'VAH', 'type': 'resistance', 'price': vah}
    elif abs(price - val) / val < tolerance:
        return {'level': 'VAL', 'type': 'support', 'price': val}
 
    return {'level': None, 'type': None, 'price': None}

@dataclass
class VolumeProfileConfig:
    row_count: int = 24          # Number of price bins
    value_area_pct: float = 0.70 # Value area percentage
    hvn_threshold: float = 1.5   # HVN multiplier of average
    lvn_threshold: float = 0.5   # LVN multiplier of average

from indicators.volume_profile import calculate_volume_profile
from config.settings import VolumeProfileConfig
 
# Load price data
df = load_ohlcv_data("EUR_USD", "1H")
 
# Configure indicator
config = VolumeProfileConfig(row_count=24, value_area_pct=0.70)
 
# Calculate Volume Profile
vp = calculate_volume_profile(df, config.row_count, config.value_area_pct)
 
# Display key levels
print(f"Point of Control (POC): {vp['poc']:.5f}")
print(f"Value Area High (VAH): {vp['vah']:.5f}")
print(f"Value Area Low (VAL):  {vp['val']:.5f}")
 
# Check current price position
current_price = df['close'].iloc[-1]
 
if current_price > vp['vah']:
    print("Price ABOVE value area - Extended/Overbought")
elif current_price < vp['val']:
    print("Price BELOW value area - Extended/Oversold")
else:
    print("Price WITHIN value area - Fair value")

def identify_volume_nodes(
    profile: pd.Series,
    hvn_threshold: float = 1.5,
    lvn_threshold: float = 0.5
) -> dict:
    """Identify High and Low Volume Nodes."""
 
    avg_volume = profile.mean()
 
    hvn = profile[profile >= avg_volume * hvn_threshold].index.tolist()
    lvn = profile[profile <= avg_volume * lvn_threshold].index.tolist()
 
    return {
        'hvn': hvn,  # High Volume Nodes (strong S/R)
        'lvn': lvn   # Low Volume Nodes (avoid)
    }