Pine Scripts — copy into TradingView. Descriptive only.

• ORB Range Marker Copy
  Opening-range high/low (Pine v6). Default 15m ET session box (09:30–09:45), confirmed-close breakout labels, multi-day range boxes. // ORB — public opening-range breakout levels (15m default, America/New_York). // Descriptive only. Not investment advice. //@version=6 indicator( title = "ORB", shorttitle = "ORB15m", overlay = true, max_boxes_count = 500, max_labels_count = 500 ) //--------------------------------------------------------------------------------------------------------------------- // CONSTANTS //--------------------------------------------------------------------------------------------------------------------- color GREEN = #089981 color RED = #F23645 int MAX_RANGE_BOXES = 500 string ORB_TIME_ZONE = "America/New_York" string SESSION_GROUP = "ORB SESSION" string STYLE_GROUP = "STYLE" //--------------------------------------------------------------------------------------------------------------------- // INPUTS //--------------------------------------------------------------------------------------------------------------------- bool displayAllInput = input.bool( defval = true, title = "Display All Available History", group = SESSION_GROUP, tooltip = "Displays all available ORB boxes, capped at TradingView's 500-box limit." ) int initialBalanceSizeInput = input.int( defval = 10, title = "Display Last X Days", minval = 1, maxval = MAX_RANGE_BOXES, group = SESSION_GROUP, tooltip = "Used when Display All Available History is disabled." ) string initialBalanceInput = input.session( defval = "0930-0945", title = "ORB Session Time — ET", group = SESSION_GROUP ) color ibTopColorInput = input.color( defval = GREEN, title = "Buy Label Color", group = STYLE_GROUP ) color ibBottomColorInput = input.color( defval = RED, title = "Sell Label Color", group = STYLE_GROUP ) color rangeFillColorInput = input.color( defval = color.new(color.gray, 85), title = "Range Box Color", group = STYLE_GROUP ) //--------------------------------------------------------------------------------------------------------------------- // CHART VALIDATION //--------------------------------------------------------------------------------------------------------------------- if barstate.isfirst and ( not timeframe.isintraday or timeframe.in_seconds() > timeframe.in_seconds("15") ) runtime.error( "ORB 15m Clean requires an intraday chart timeframe of 15 minutes or lower." ) //--------------------------------------------------------------------------------------------------------------------- // DATA STRUCTURE //--------------------------------------------------------------------------------------------------------------------- type initialBalance int startTime int endTime float top float bottom box background var array<initialBalance> initialBalances = array.new<initialBalance>() string orbSession = initialBalanceInput + ":23456" bool insideInitialBalance = not na( time(timeframe.period, orbSession, ORB_TIME_ZONE) ) bool initialBalanceStart = insideInitialBalance and (barstate.isfirst or not insideInitialBalance[1]) int retainedHistoryLimit = displayAllInput ? MAX_RANGE_BOXES : initialBalanceSizeInput //--------------------------------------------------------------------------------------------------------------------- // HISTORY MANAGEMENT //--------------------------------------------------------------------------------------------------------------------- trimHistory(int maximumSize) => while initialBalances.size() > maximumSize initialBalance oldestInitialBalance = initialBalances.shift() if not na(oldestInitialBalance.background) box.delete(oldestInitialBalance.background) //--------------------------------------------------------------------------------------------------------------------- // ORB CALCULATION //--------------------------------------------------------------------------------------------------------------------- gatherData() => if initialBalanceStart initialBalances.push( initialBalance.new( time, time_close, high, low, na ) ) trimHistory(retainedHistoryLimit) if initialBalances.size() > 0 initialBalance currentInitialBalance = initialBalances.last() if insideInitialBalance currentInitialBalance.endTime := time_close currentInitialBalance.top := math.max(currentInitialBalance.top, high) currentInitialBalance.bottom := math.min(currentInitialBalance.bottom, low) //--------------------------------------------------------------------------------------------------------------------- // CONFIRMED-CLOSE BREAKOUTS //--------------------------------------------------------------------------------------------------------------------- breakouts() => bool bullishBreakout = false bool bearishBreakout = false if ( initialBalances.size() > 0 and not insideInitialBalance and barstate.isconfirmed ) initialBalance currentInitialBalance = initialBalances.last() bullishBreakout := close[1] <= currentInitialBalance.top and close > currentInitialBalance.top bearishBreakout := close[1] >= currentInitialBalance.bottom and close < currentInitialBalance.bottom [bullishBreakout, bearishBreakout] //--------------------------------------------------------------------------------------------------------------------- // DRAWING //--------------------------------------------------------------------------------------------------------------------- drawInitialBalance(initialBalance currentInitialBalance) => color transparentBorder = color.new(rangeFillColorInput, 100) currentInitialBalance.background := na(currentInitialBalance.background) ? box.new( left = currentInitialBalance.startTime, top = currentInitialBalance.top, right = currentInitialBalance.endTime, bottom = currentInitialBalance.bottom, xloc = xloc.bar_time, border_color = transparentBorder, bgcolor = rangeFillColorInput ) : currentInitialBalance.background box.set_left( currentInitialBalance.background, currentInitialBalance.startTime ) box.set_right( currentInitialBalance.background, currentInitialBalance.endTime ) box.set_top( currentInitialBalance.background, currentInitialBalance.top ) box.set_bottom( currentInitialBalance.background, currentInitialBalance.bottom ) box.set_border_color( currentInitialBalance.background, transparentBorder ) box.set_bgcolor( currentInitialBalance.background, rangeFillColorInput ) currentInitialBalance.background drawInitialBalances() => if initialBalances.size() > 0 for currentInitialBalance in initialBalances drawInitialBalance(currentInitialBalance) //--------------------------------------------------------------------------------------------------------------------- // EXECUTION //--------------------------------------------------------------------------------------------------------------------- gatherData() [bullishBreakout, bearishBreakout] = breakouts() plotshape( series = bullishBreakout, title = "ORB Buy", style = shape.labelup, location = location.belowbar, color = ibTopColorInput, size = size.small, text = "ORB", textcolor = color.white ) plotshape( series = bearishBreakout, title = "ORB Sell", style = shape.labeldown, location = location.abovebar, color = ibBottomColorInput, size = size.small, text = "ORB", textcolor = color.white ) alertcondition( condition = bullishBreakout, title = "ORB Buy Breakout", message = "{{ticker}} {{interval}} closed above the 15-minute ORB range at {{close}}." ) alertcondition( condition = bearishBreakout, title = "ORB Sell Breakout", message = "{{ticker}} {{interval}} closed below the 15-minute ORB range at {{close}}." ) if barstate.islastconfirmedhistory drawInitialBalances() if barstate.islast and initialBalances.size() > 0 drawInitialBalance(initialBalances.last())
• Nebula Bands Copy
  Quantum Wave environment layer (Pine v6). Harmonic Fibonacci tiers and energy visuals. //@version=6 indicator("Quantum Wave [Environment Layer]", shorttitle="Q-Wave", overlay=true) // ═══════════════════════════════════════════════════════════ // 🌊 QUANTUM SETTINGS // ═══════════════════════════════════════════════════════════ group_wave = "Wave Physics" i_wave_len = input.int(21, "Wave Baseline Length", minval=5, group=group_wave, tooltip="The anchor point for the harmonic calculation.") i_smooth = input.string("EMA", "Wave Type", options=["EMA", "SMA", "RMA", "WMA"], group=group_wave) i_flux = input.int(14, "Energy Lookback", group=group_wave, tooltip="Used to calculate the intensity of the trend.") group_vis = "Visuals" c_bull_high = input.color(#00E676, "Bull High Energy", group=group_vis) c_bull_low = input.color(#004D2C, "Bull Low Energy", group=group_vis) c_bear_high = input.color(#FF5252, "Bear High Energy", group=group_vis) c_bear_low = input.color(#4D0000, "Bear Low Energy", group=group_vis) c_neutral = input.color(#5d606b, "Neutral / Compressed", group=group_vis) // ═══════════════════════════════════════════════════════════ // 📐 HARMONIC CALCULATIONS // ═══════════════════════════════════════════════════════════ // FIX: Replaced ternary chain with 'switch' to prevent indentation errors f_ma(source, length, type) => switch type "SMA" => ta.sma(source, length) "EMA" => ta.ema(source, length) "RMA" => ta.rma(source, length) => ta.wma(source, length) // Generate Harmonic Fibonacci Tiers // We create a ribbon based on the Golden Ratio (1.618) relationships relative to the baseline // We use int(math.round()) to ensure valid integer lengths len_1 = int(math.round(i_wave_len)) len_2 = int(math.round(i_wave_len * 1.382)) len_3 = int(math.round(i_wave_len * 1.618)) len_4 = int(math.round(i_wave_len * 2.0)) len_5 = int(math.round(i_wave_len * 2.618)) // Calculate Wave Layers ma1 = f_ma(close, len_1, i_smooth) ma2 = f_ma(close, len_2, i_smooth) ma3 = f_ma(close, len_3, i_smooth) ma4 = f_ma(close, len_4, i_smooth) ma5 = f_ma(close, len_5, i_smooth) // ═══════════════════════════════════════════════════════════ // ⚡ ENERGY & FLUX LOGIC // ═══════════════════════════════════════════════════════════ // 1. Calculate Trend Direction based on the "Head" (ma1) vs "Tail" (ma5) trend_direction = ma1 > ma5 ? 1 : -1 // 2. Calculate "Flux" (Expansion/Compression) // We measure the width of the ribbon relative to the asset's volatility (ATR) ribbon_width = math.abs(ma1 - ma5) volatility_norm = ta.atr(i_flux) flux_ratio = ribbon_width / volatility_norm // 3. Determine Intensity // If flux is low, the ribbon is compressed (potential energy). // If flux is high, the ribbon is expanded (kinetic energy). intensity = math.min(flux_ratio, 2.0) / 2.0 // Normalized 0.0 to 1.0 // ═══════════════════════════════════════════════════════════ // 🎨 DYNAMIC COLOR GENERATION // ═══════════════════════════════════════════════════════════ // Generate gradient colors based on Intensity f_get_wave_color(dir, intense) => if dir > 0 color.from_gradient(intense, 0.0, 1.0, c_neutral, c_bull_high) else color.from_gradient(intense, 0.0, 1.0, c_neutral, c_bear_high) color_wave = f_get_wave_color(trend_direction, intensity) // ═══════════════════════════════════════════════════════════ // 🌊 PLOTTING // ═══════════════════════════════════════════════════════════ // We plot the "Skeleton" invisible, then fill the "Flesh" p1 = plot(ma1, display=display.none) p2 = plot(ma2, display=display.none) p3 = plot(ma3, display=display.none) p4 = plot(ma4, display=display.none) p5 = plot(ma5, display=display.none) // The fills create the "Wave" effect with varying transparency to simulate depth fill(p1, p2, color=color.new(color_wave, 30), title="Wave Core") fill(p2, p3, color=color.new(color_wave, 50), title="Wave Inner") fill(p3, p4, color=color.new(color_wave, 70), title="Wave Outer") fill(p4, p5, color=color.new(color_wave, 80), title="Wave Edge") // ═══════════════════════════════════════════════════════════ // 📊 QUANTUM STATE DASHBOARD // ═══════════════════════════════════════════════════════════ // A simple status monitor to read the environment without chart clutter var table state_table = table.new(position.bottom_right, 2, 3, bgcolor=color.new(color.black, 50), border_width=1) if barstate.islast // Determine State Text state_txt = flux_ratio < 0.5 ? "COMPRESSED" : flux_ratio > 1.5 ? "OVER-EXTENDED" : "FLOWING" state_col = flux_ratio < 0.5 ? color.gray : flux_ratio > 1.5 ? color.orange : color.green dir_txt = trend_direction > 0 ? "BULLISH" : "BEARISH" dir_col = trend_direction > 0 ? c_bull_high : c_bear_high // Header table.cell(state_table, 0, 0, "QUANTUM STATE", text_color=color.white, text_size=size.small, bgcolor=color.new(color.black, 100)) // Direction Row table.cell(state_table, 0, 1, "BIAS", text_color=color.white, text_size=size.small, bgcolor=color.new(color.gray, 90)) table.cell(state_table, 1, 1, dir_txt, text_color=dir_col, text_size=size.small, bgcolor=color.new(dir_col, 85)) // Energy Row table.cell(state_table, 0, 2, "ENERGY", text_color=color.white, text_size=size.small, bgcolor=color.new(color.gray, 90)) table.cell(state_table, 1, 2, state_txt, text_color=state_col, text_size=size.small, bgcolor=color.new(state_col, 85))
• Nebula Volume Profile Copy
  Harmonic quantum volume & gaps (Pine v6). Volume profile with quantum wave context. //@version=6 indicator("Harmonic Quantum Volume & Gaps ", overlay = true, max_boxes_count = 500, max_labels_count = 500) // ═══════════════════════════════ 1. QUANTUM WAVE INPUTS ═══════════════════════════════ var g_wave = "Quantum Harmony" int i_wave_len = input.int(21, "Wave Baseline", group=g_wave) int i_flux_len = input.int(14, "Flux Lookback", group=g_wave) // ═══════════════════════════════ 2. PROFILE INPUTS ═══════════════════════════════ var g_prof = "Profile Settings" int prd = input.int(200, "Lookback", minval = 50, maxval = 2000, group=g_prof) int rows = input.int(50, "Rows", minval = 10, maxval = 100, group=g_prof) int width = input.int(100, "Width", minval = 1, maxval = 500, group=g_prof) // Colors color c_bull_vol = color.new(#00E676, 70) // Quantum Green color c_bear_vol = color.new(#FF5252, 70) // Quantum Red color c_target = color.new(#FFD700, 40) // Gold (Magnet) color c_support = color.new(#00E676, 50) // Green Support color c_resist = color.new(#FF5252, 50) // Red Resistance // ═══════════════════════════════ 3. QUANTUM CALCULATIONS ═══════════════════════════════ f_ma(src, len) => ta.ema(src, len) len_1 = i_wave_len len_5 = math.round(i_wave_len * 2.618) ma_fast = f_ma(close, len_1) ma_slow = f_ma(close, len_5) // Trend & Physics bool q_bull = ma_fast > ma_slow bool q_bear = ma_fast < ma_slow float flux = math.abs(ma_fast - ma_slow) / ta.atr(i_flux_len) bool q_flowing = flux > 0.5 // Market is active // ═══════════════════════════════ 4. VOLUME PROFILE ENGINE ═══════════════════════════════ b = bar_index hi = ta.highest(high, prd) lo = ta.lowest(low, prd) // Arrays var lvls = array.new_float() var bull_vols = array.new_float() var bear_vols = array.new_float() var zone_boxes = array.new_box() if barstate.islast // Cleanup for b_ in box.all box.delete(b_) for l_ in label.all label.delete(l_) // Reset Arrays array.clear(lvls) array.clear(bull_vols) array.clear(bear_vols) array.clear(zone_boxes) // Build Levels float step = (hi - lo) / rows for i = lo to hi by step array.push(lvls, i) array.push(bull_vols, 0.0) array.push(bear_vols, 0.0) // Populate Volume for i = prd to 0 float p = close[i] // Using Close for precision bool is_up = close[i] >= open[i] // Find bin int bin_idx = int((p - lo) / step) if bin_idx >= 0 and bin_idx < array.size(bull_vols) if is_up array.set(bull_vols, bin_idx, array.get(bull_vols, bin_idx) + volume[i]) else array.set(bear_vols, bin_idx, array.get(bear_vols, bin_idx) + volume[i]) // Find Max Volume for scaling float max_vol = 0.0 for i = 0 to array.size(bull_vols) - 1 float total = array.get(bull_vols, i) + array.get(bear_vols, i) if total > max_vol max_vol := total // ═══════════════════════════════ 5. DRAWING & GAP DETECTION ═══════════════════════════════ // Variables to find the "Magnet" (Nearest gap in trend direction) float min_dist_target = 999999.9 float target_level = na int size = array.size(lvls) if size > 1 for i = 0 to size - 2 float lvl_bot = array.get(lvls, i) float lvl_top = array.get(lvls, i+1) float lvl_mid = (lvl_bot + lvl_top) / 2 float v_bull = array.get(bull_vols, i) float v_bear = array.get(bear_vols, i) float v_total = v_bull + v_bear // --- DRAW PROFILE BARS --- if v_total > 0 int bar_len = int((v_total / max_vol) * width) if bar_len > 0 int len_bull = int((v_bull / v_total) * bar_len) int len_bear = bar_len - len_bull int start_x = b + width - bar_len // Bull Portion if len_bull > 0 box.new(start_x, lvl_top, start_x + len_bull, lvl_bot, border_color=na, bgcolor=c_bull_vol) // Bear Portion if len_bear > 0 box.new(start_x + len_bull, lvl_top, b + width, lvl_bot, border_color=na, bgcolor=c_bear_vol) // --- GAP DETECTION (ZERO VOLUME) --- if v_total == 0 // This is a GAP. Determine its harmonic role. color gap_col = color.new(color.gray, 80) // Default Neutral // Logic: // 1. If Bullish Trend & Gap is ABOVE price -> MAGNET (Target) // 2. If Bullish Trend & Gap is BELOW price -> SUPPORT (Buy Zone) // 3. If Bearish Trend & Gap is BELOW price -> MAGNET (Target) bool is_above = lvl_bot > close bool is_below = lvl_top < close if q_bull if is_above gap_col := c_target // Magnet // Check if this is the NEAREST target if (lvl_bot - close) < min_dist_target min_dist_target := lvl_bot - close target_level := lvl_mid if is_below gap_col := c_support // Support if q_bear if is_below gap_col := c_target // Magnet // Check if this is the NEAREST target if (close - lvl_top) < min_dist_target min_dist_target := close - lvl_top target_level := lvl_mid if is_above gap_col := c_resist // Resistance // Create the Box box b_gap = box.new(b - prd, lvl_top, b, lvl_bot, border_color=na, bgcolor=gap_col) array.push(zone_boxes, b_gap) // ═══════════════════════════════ 6. MAGNET LABEL ═══════════════════════════════ // Mark the "Most Probable" fill area if not na(target_level) and q_flowing label.new(b + 5, target_level, "🧲 PRIME TARGET", color=color.new(color.yellow, 0), style=label.style_label_left, textcolor=color.black, size=size.small) // ═══════════════════════════════ 7. BOX MERGING ═══════════════════════════════ // Merge adjacent gaps to clean up the chart if array.size(zone_boxes) > 1 int i = 0 while i < array.size(zone_boxes) - 1 box b_curr = array.get(zone_boxes, i) box b_next = array.get(zone_boxes, i+1) // If boxes touch if math.abs(box.get_top(b_curr) - box.get_bottom(b_next)) < 0.0001 // Extend current box top to next box top box.set_top(b_curr, box.get_top(b_next)) // Delete next box box.delete(b_next) array.remove(zone_boxes, i+1) // Stay on current index to check next one else i += 1
• Session RVOL Overlay Copy
  Same-clock session relative volume vs prior RTH bars (Pine v6). Quiet / Normal / Elevated guides. //@version=6 // Session RVOL Overlay — public descriptive relative volume for the RTH session. // Compares bar volume to prior sessions at the same time of day. // Descriptive only. Not investment advice. Not a trade signal. indicator( "Session RVOL Overlay", shorttitle="Sess RVOL", overlay=false ) // ── Inputs ────────────────────────────────────────────────────────────────── sessInput = input.session( "0930-1600", "RTH session", group="Session" ) tzInput = input.string( "America/New_York", "Timezone", group="Session" ) lookback = input.int( 20, "Same-clock lookback sessions", minval=5, maxval=60, group="RVOL" ) minSamples = input.int( 5, "Min prior samples for AVAILABLE", minval=3, maxval=20, group="RVOL" ) quietMax = input.float( 0.80, "Quiet max (×)", minval=0.10, step=0.05, group="Bands" ) normalMax = input.float( 1.50, "Normal max (×)", minval=0.50, step=0.05, group="Bands" ) elevatedMax = input.float( 2.50, "Elevated max (×)", minval=1.00, step=0.05, group="Bands" ) showBands = input.bool( true, "Show band guide levels", group="Display" ) // ── Timeframe and session ─────────────────────────────────────────────────── tfSeconds = timeframe.in_seconds() supportedTf = timeframe.isintraday and not na(tfSeconds) and tfSeconds <= 3600 inSess = supportedTf and not na(time(timeframe.period, sessInput, tzInput)) // ── Same-clock key ────────────────────────────────────────────────────────── barHour = hour(time, tzInput) barMinute = minute(time, tzInput) clockKey = barHour * 60 + barMinute // ── Rolling same-clock storage ────────────────────────────────────────────── var array<float> volumeRing = array.new_float(1440 * lookback, na) var array<float> rollingSum = array.new_float(1440, 0.0) var array<int> sampleCounts = array.new_int(1440, 0) var array<int> writePositions = array.new_int(1440, 0) // Read historical baseline before recording the current bar. storedSum = supportedTf ? array.get(rollingSum, clockKey) : 0.0 sampleN = supportedTf ? array.get(sampleCounts, clockKey) : 0 avgSame = sampleN > 0 ? storedSum / sampleN : na // ── Current RVOL ──────────────────────────────────────────────────────────── rvol = inSess and volume > 0 and not na(avgSame) and avgSame > 0 ? volume / avgSame : na available = inSess and sampleN >= minSamples and not na(rvol) // ── Preserve latest RTH reading ───────────────────────────────────────────── var float lastRthRvol = na var int lastRthSamples = 0 var bool lastRthAvailable = false if inSess lastRthSamples := sampleN lastRthAvailable := available if not na(rvol) lastRthRvol := rvol displayRvol = inSess ? rvol : lastRthRvol displaySamples = inSess ? sampleN : lastRthSamples hasStoredRth = not na(lastRthRvol) // ── Record completed RTH bar ──────────────────────────────────────────────── if inSess and barstate.isconfirmed and volume > 0 currentCount = array.get(sampleCounts, clockKey) writePosition = array.get(writePositions, clockKey) ringIndex = clockKey * lookback + writePosition currentSum = array.get(rollingSum, clockKey) oldVolume = array.get(volumeRing, ringIndex) if currentCount < lookback array.set( volumeRing, ringIndex, volume ) array.set( rollingSum, clockKey, currentSum + volume ) array.set( sampleCounts, clockKey, currentCount + 1 ) else removedVolume = na(oldVolume) ? 0.0 : oldVolume array.set( volumeRing, ringIndex, volume ) array.set( rollingSum, clockKey, currentSum - removedVolume + volume ) nextPosition = writePosition + 1 if nextPosition >= lookback nextPosition := 0 array.set( writePositions, clockKey, nextPosition ) // ── Colors ────────────────────────────────────────────────────────────────── bandColor = not available ? color.new(color.gray, 40) : rvol <= quietMax ? color.new(#7e57c2, 0) : rvol <= normalMax ? color.new(#26a69a, 0) : rvol <= elevatedMax ? color.new(#ffb74d, 0) : color.new(#ff5252, 0) // ── RVOL plot ─────────────────────────────────────────────────────────────── plot( available ? rvol : na, "Session RVOL", color=bandColor, linewidth=2, style=plot.style_histogram ) hline( 1.0, "Parity", color=color.new(color.white, 70), linestyle=hline.style_dotted ) plot( showBands and supportedTf ? quietMax : na, "Quiet max", color=color.new(#7e57c2, 70) ) plot( showBands and supportedTf ? normalMax : na, "Normal max", color=color.new(#26a69a, 70) ) plot( showBands and supportedTf ? elevatedMax : na, "Elevated max", color=color.new(#ffb74d, 70) ) // ── Table status ──────────────────────────────────────────────────────────── statusText = not supportedTf ? "UNSUPPORTED TF" : inSess and available ? "AVAILABLE" : inSess ? "LEARNING" : hasStoredRth ? "LAST RTH" : "NO RTH DATA" statusColor = not supportedTf ? color.orange : inSess and available ? color.lime : inSess ? color.yellow : hasStoredRth ? color.aqua : color.gray // ── Information table ─────────────────────────────────────────────────────── var table info = table.new( position.top_right, 2, 3, bgcolor=color.new(#120722, 10), frame_color=color.new(color.white, 70), frame_width=1, border_color=color.new(color.white, 80), border_width=1 ) if barstate.islast table.cell( info, 0, 0, "Status", text_color=color.gray, text_size=size.small ) table.cell( info, 1, 0, statusText, text_color=statusColor, text_size=size.small ) table.cell( info, 0, 1, "Samples", text_color=color.gray, text_size=size.small ) table.cell( info, 1, 1, supportedTf and (inSess or hasStoredRth) ? str.tostring(displaySamples) : "—", text_color=color.white, text_size=size.small ) table.cell( info, 0, 2, "RVOL", text_color=color.gray, text_size=size.small ) table.cell( info, 1, 2, not na(displayRvol) ? str.tostring(displayRvol, "#.##") : "—", text_color=color.white, text_size=size.small )
• Fundamental Dashboard Copy
  TradingView request.financial fundamentals table + optional pivots (Pine v6). //@version=6 // Fundamental Dashboard // Pulls company financials from TradingView via request.financial (FactSet-backed // metrics available on the chart symbol). Works on equities with financial coverage. // Crypto / FX / futures generally have no financials — cells show N/A. // Calculated fields (mkt cap, P/E) use chart close × financial series. // Descriptive research display only. Not investment advice. indicator("Fundamental Dashboard", overlay=true, max_lines_count=100) // ========================================== // 1. SETTINGS & INPUTS // ========================================== grp_display = "Dashboard Settings" tableSize = input.string("Small", "Table Size", options=["Tiny", "Small", "Normal", "Large"], group=grp_display) tablePos = input.string("Top Right", "Position", options=["Top Right", "Bottom Right", "Top Left", "Bottom Left"], group=grp_display) compactMode = input.bool(false, "Compact Mode (For Phone)", tooltip="Shortens text to fit narrow screens", group=grp_display) grp_fin = "Financial periods" // Prefer diluted EPS for P/E (official PE example uses TTM EPS). epsId = input.string("EARNINGS_PER_SHARE_DILUTED", "EPS metric id", options=["EARNINGS_PER_SHARE_DILUTED", "EARNINGS_PER_SHARE_BASIC"], group=grp_fin) sharesPeriod = input.string("FQ", "Shares outstanding period", options=["FQ", "FY", "FH"], group=grp_fin) flowPeriod = input.string("TTM", "Income / cash-flow period", options=["TTM", "FY", "FQ", "FH"], group=grp_fin) snapPeriod = input.string("FQ", "Balance-sheet period", options=["FQ", "FY", "FH"], group=grp_fin) statPeriod = input.string("FQ", "TV ratio stats period (ROE/ROIC/etc.)", options=["FQ", "FY", "FH"], group=grp_fin) grp_tech = "Technical Settings" showPivots = input.bool(true, "Show Pivot Support/Resistance", group=grp_tech) leftLen = input.int(15, "Pivot Left Bars", minval=1, group=grp_tech) rightLen = input.int(15, "Pivot Right Bars", minval=1, group=grp_tech) // ========================================== // 2. TRADINGVIEW FINANCIALS (request.financial) // IDs and periods match TradingView's published Pine financial catalog. // ========================================== // Keep na when a metric is unavailable — do NOT coerce missing to 0. f(id, period) => request.financial(syminfo.tickerid, id, period) // --- Core series from TradingView financials --- eps_ttm = f(epsId, flowPeriod) // TTM diluted/basic EPS shares_out = f("TOTAL_SHARES_OUTSTANDING", sharesPeriod) // FQ/FY shares rev_ttm = f("TOTAL_REVENUE", flowPeriod) net_inc_ttm = f("NET_INCOME", flowPeriod) equity = f("TOTAL_EQUITY", snapPeriod) debt = f("TOTAL_DEBT", snapPeriod) gross_profit = f("GROSS_PROFIT", flowPeriod) fcf_ttm = f("FREE_CASH_FLOW", flowPeriod) // Official one-year revenue growth % from TV (avoids fragile daily lookback hacks) rev_yoy_tv = f("REVENUE_ONE_YEAR_GROWTH", flowPeriod) // Native TV statistics (already %). Prefer these over hand-rolled ratios when present. roe_tv = f("RETURN_ON_EQUITY", statPeriod) roic_tv = f("RETURN_ON_INVESTED_CAPITAL", statPeriod) gm_tv = f("GROSS_MARGIN", flowPeriod) de_tv = f("DEBT_TO_EQUITY", statPeriod) // ratio (e.g. 0.8), not percent // --- Chart-linked calculations (TV docs: mkt cap / PE pattern) --- current_price = close mkt_cap = not na(shares_out) ? current_price * shares_out : na pe_ratio = not na(eps_ttm) and eps_ttm > 0 ? current_price / eps_ttm : na // Fallbacks only when TV stats are missing for the symbol roe_calc = not na(equity) and not na(net_inc_ttm) and equity != 0 ? (net_inc_ttm / equity) * 100.0 : na roic_calc = not na(equity) and not na(debt) and not na(net_inc_ttm) and (equity + debt) != 0 ? (net_inc_ttm / (equity + debt)) * 100.0 : na gm_calc = not na(rev_ttm) and not na(gross_profit) and rev_ttm != 0 ? (gross_profit / rev_ttm) * 100.0 : na de_calc = not na(equity) and not na(debt) and equity != 0 ? debt / equity : na roe = not na(roe_tv) ? roe_tv : roe_calc roic = not na(roic_tv) ? roic_tv : roic_calc gross_margin = not na(gm_tv) ? gm_tv : gm_calc debt_eq = not na(de_tv) ? de_tv : de_calc // ratio debt_eq_pct = not na(debt_eq) ? debt_eq * 100.0 : na // Prefer TV revenue growth; optional manual fallback using prior TTM print is unreliable in Pine growth_yoy = rev_yoy_tv // --- Technical: distance from highest high in loaded chart history (not guaranteed all-time) --- var float ath = na ath := na(ath) ? high : math.max(ath, high) ath_dist = not na(ath) and ath > 0 ? ((close - ath) / ath) * 100.0 : na // ========================================== // 3. FORMATTING HELPERS // ========================================== fmt_num(n) => na(n) ? "N/A" : math.abs(n) >= 1e12 ? str.tostring(n / 1e12, "#.##") + "T" : math.abs(n) >= 1e9 ? str.tostring(n / 1e9, "#.##") + "B" : math.abs(n) >= 1e6 ? str.tostring(n / 1e6, "#.##") + "M" : str.tostring(n, "#.##") fmt_pct(n) => na(n) ? "N/A" : str.tostring(n, "#.1") + "%" fmt_pe(n) => na(n) ? "N/A" : str.tostring(n, "#.1") get_size(s) => s == "Tiny" ? size.tiny : s == "Small" ? size.small : s == "Normal" ? size.normal : size.large get_pos(p) => p == "Top Right" ? position.top_right : p == "Bottom Right" ? position.bottom_right : p == "Top Left" ? position.top_left : position.bottom_left // ========================================== // 4. DASHBOARD TABLE // ========================================== if barstate.islast var table dash = table.new(get_pos(tablePos), 2, 12, border_width=1) c_head = color.new(color.blue, 30) c_bg = color.new(color.black, 20) t_size = get_size(tableSize) // Row 0: Market Cap (TV pattern: shares FQ × close) table.cell(dash, 0, 0, compactMode ? "Mkt Cap" : "Market Cap", bgcolor=c_head, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 0, fmt_num(mkt_cap), bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 1: Revenue YoY (TV REVENUE_ONE_YEAR_GROWTH) c_growth = na(growth_yoy) ? color.gray : growth_yoy > 15 ? color.green : growth_yoy > 0 ? color.new(color.green, 40) : color.red txt_growth = na(growth_yoy) ? "N/A" : (growth_yoy > 0 ? "+" : "") + str.tostring(growth_yoy, "#.1") + "%" table.cell(dash, 0, 1, compactMode ? "Rev YoY" : "Rev Growth", bgcolor=c_head, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 1, txt_growth, bgcolor=c_growth, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 2: From chart high c_ath = na(ath_dist) ? color.gray : ath_dist > -5 ? color.green : ath_dist < -20 ? color.red : color.orange table.cell(dash, 0, 2, compactMode ? "ATH*" : "From ATH*", bgcolor=c_head, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 2, fmt_pct(ath_dist), bgcolor=c_ath, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 3: P/E (close / TTM EPS) — official TV calculation pattern c_pe = na(pe_ratio) ? color.gray : pe_ratio < 20 ? color.green : pe_ratio > 50 ? color.red : color.orange table.cell(dash, 0, 3, "P/E Ratio", bgcolor=c_head, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 3, fmt_pe(pe_ratio), bgcolor=c_pe, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Divider table.cell(dash, 0, 4, compactMode ? "TV" : "— TV Financials —", bgcolor=color.black, text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, 4, compactMode ? "DATA" : "— request.financial —", bgcolor=color.black, text_color=color.gray, text_size=size.tiny) // Row 5: ROE c_roe = na(roe) ? color.gray : roe > 15 ? color.green : roe < 0 ? color.red : color.orange table.cell(dash, 0, 5, compactMode ? "ROE" : "ROE", bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 5, fmt_pct(roe), bgcolor=c_roe, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 6: ROIC c_roic = na(roic) ? color.gray : roic > 10 ? color.green : roic < 0 ? color.red : color.orange table.cell(dash, 0, 6, compactMode ? "ROIC" : "ROIC", bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 6, fmt_pct(roic), bgcolor=c_roic, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 7: Gross Margin c_gm = na(gross_margin) ? color.gray : gross_margin > 40 ? color.green : gross_margin < 20 ? color.red : color.gray table.cell(dash, 0, 7, compactMode ? "Margin" : "Gross Margin", bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 7, fmt_pct(gross_margin), bgcolor=c_gm, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 8: Debt/Equity (shown as %) c_de = na(debt_eq_pct) ? color.gray : debt_eq_pct < 80 ? color.green : debt_eq_pct > 200 ? color.red : color.orange table.cell(dash, 0, 8, compactMode ? "D/E" : "Debt/Equity", bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 8, fmt_pct(debt_eq_pct), bgcolor=c_de, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Row 9: Free Cash Flow (TTM) c_fcf = na(fcf_ttm) ? color.gray : fcf_ttm > 0 ? color.green : color.red table.cell(dash, 0, 9, "FCF", bgcolor=c_bg, text_color=color.white, text_size=t_size, text_halign=text.align_left) table.cell(dash, 1, 9, fmt_num(fcf_ttm), bgcolor=c_fcf, text_color=color.white, text_size=t_size, text_halign=text.align_right) // Footnote row table.cell(dash, 0, 10, "*chart high", bgcolor=color.black, text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, 10, "TV financials", bgcolor=color.black, text_color=color.gray, text_size=size.tiny) // ========================================== // 5. PIVOT LINES (optional technical overlay) // ========================================== if showPivots ph = ta.pivothigh(leftLen, rightLen) pl = ta.pivotlow(leftLen, rightLen) var line[] resLines = array.new_line(0) var line[] supLines = array.new_line(0) maxLines = 6 if not na(ph) l = line.new(bar_index[rightLen], ph, bar_index, ph, color=color.new(color.red, 40), width=1) array.push(resLines, l) if array.size(resLines) > maxLines line.delete(array.shift(resLines)) if not na(pl) l = line.new(bar_index[rightLen], pl, bar_index, pl, color=color.new(color.green, 40), width=1) array.push(supLines, l) if array.size(supLines) > maxLines line.delete(array.shift(supLines)) if barstate.islast if array.size(resLines) > 0 for i = 0 to array.size(resLines) - 1 line.set_x2(array.get(resLines, i), bar_index) if array.size(supLines) > 0 for i = 0 to array.size(supLines) - 1 line.set_x2(array.get(supLines, i), bar_index)
• Liquidity Sweep Flag Copy
  Swing pierce-and-reclaim liquidity sweep flags (Pine v6). //@version=6 // Liquidity Sweep Flag — descriptive wick/liquidity notes only. // Flags confirmed bars that pierce a recent extreme and close back inside. // Descriptive structure annotation. Not a trade signal. Not investment advice. indicator( "Liquidity Sweep Flag", shorttitle="Liq Sweep", overlay=true, max_labels_count=100 ) // ── Inputs ────────────────────────────────────────────────────────────────── swingLen = input.int( 10, "Swing lookback (bars)", minval=3, maxval=50, group="Structure" ) wickMinAtr = input.float( 0.35, "Min wick size (× ATR)", minval=0.10, step=0.05, group="Wick" ) atrLen = input.int( 14, "ATR length", minval=5, group="Wick" ) bodyMaxFrac = input.float( 0.55, "Max body as fraction of range", minval=0.10, maxval=0.95, step=0.05, group="Wick" ) showLabels = input.bool( false, "Show labels", group="Display" ) showLevels = input.bool( true, "Show active swing levels", group="Display" ) lowSweepColor = input.color( color.new(#00e888, 0), "Low-side sweep color", group="Display" ) highSweepColor = input.color( color.new(#ff5252, 0), "High-side sweep color", group="Display" ) // ── Candle structure ──────────────────────────────────────────────────────── atr = ta.atr(atrLen) barRange = high - low bodySize = math.abs(close - open) upperWick = high - math.max(open, close) lowerWick = math.min(open, close) - low // ── Prior extremes ────────────────────────────────────────────────────────── // Excludes the current candle. priorHigh = ta.highest(high[1], swingLen) priorLow = ta.lowest(low[1], swingLen) // ── Sweep conditions ──────────────────────────────────────────────────────── validBar = barstate.isconfirmed and not na(atr) and atr > 0 and barRange > 0 and not na(priorHigh) and not na(priorLow) // Price trades above the prior high, but the confirmed candle closes below it. highSweep = validBar and high > priorHigh and close < priorHigh and upperWick >= wickMinAtr * atr and bodySize <= bodyMaxFrac * barRange // Price trades below the prior low, but the confirmed candle closes above it. lowSweep = validBar and low < priorLow and close > priorLow and lowerWick >= wickMinAtr * atr and bodySize <= bodyMaxFrac * barRange // ── Markers ───────────────────────────────────────────────────────────────── plotshape( highSweep, title="High-side liquidity sweep", style=shape.triangledown, location=location.abovebar, color=highSweepColor, size=size.tiny ) plotshape( lowSweep, title="Low-side liquidity sweep", style=shape.triangleup, location=location.belowbar, color=lowSweepColor, size=size.tiny ) // ── Labels ────────────────────────────────────────────────────────────────── if showLabels and highSweep label.new( bar_index, high, "sweep H", style=label.style_label_down, color=color.new(highSweepColor, 70), textcolor=highSweepColor, size=size.tiny ) if showLabels and lowSweep label.new( bar_index, low, "sweep L", style=label.style_label_up, color=color.new(lowSweepColor, 70), textcolor=lowSweepColor, size=size.tiny ) // ── Reference levels ──────────────────────────────────────────────────────── plot( showLevels ? priorHigh : na, "Prior swing high", color=color.new(highSweepColor, 85), linewidth=1, style=plot.style_linebr ) plot( showLevels ? priorLow : na, "Prior swing low", color=color.new(lowSweepColor, 85), linewidth=1, style=plot.style_linebr ) // ── Alerts ────────────────────────────────────────────────────────────────── alertcondition( highSweep, "High-side liquidity sweep", "A confirmed bar pierced the prior swing high and closed back below it." ) alertcondition( lowSweep, "Low-side liquidity sweep", "A confirmed bar pierced the prior swing low and closed back above it." )

Pythons — three same-clock volume tools, one per question: a scanner that ranks your watchlist, a curve you can watch trace out today's pace, and a session heatmap. Default feed is yfinance (often ~15m delayed); swap load_bars() for your own source. The two charts need matplotlib.

• Same-Clock RVOL Scanner Copy
  Rank index ETFs (SPY/QQQ/DIA/IWM) + the Magnificent Seven by how unusual volume is right now versus the same minute of the day. Prints a terminal leaderboard. yfinance by default — personalize load_bars(). #!/usr/bin/env python3 """Same-Clock RVOL Scanner — Nebula HQ Rank a watchlist by how unusual its volume is *right now* versus the same minute of the day across recent sessions. One question, one leaderboard: which names are trading hot for this time of day, and which are asleep. RVOL(now) = cumulative volume so far today -------------------------------------------------- avg cumulative volume at this same session-minute across the last N sessions (same clock, prior days) Comparing to the *same clock* is the whole point: 40M shares by 10:00 means nothing until you know this name usually trades 25M by 10:00. DEFAULT DATA FEED yfinance — free, typically ~15-minute delayed US equity data. Descriptive only. Not investment advice. PERSONALIZE Swap load_bars() for your broker / vendor / CSV. Keep the columns open, high, low, close, volume and a timezone-aware index (ET preferred). Edit WATCHLIST for your own names. pip install yfinance pandas """ from __future__ import annotations import sys from zoneinfo import ZoneInfo import pandas as pd ET = ZoneInfo("America/New_York") # Render box-drawing / block glyphs even on a legacy Windows (cp1252) console. try: sys.stdout.reconfigure(encoding="utf-8") except (AttributeError, ValueError): pass # Index ETFs (S&P 500 / Nasdaq-100 / Dow / Russell 2000) + the Magnificent Seven. WATCHLIST = ["SPY", "QQQ", "DIA", "IWM", "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA"] LOOKBACK_SESSIONS = 20 MIN_SESSIONS = 5 # ── Nebula terminal palette (256-color ANSI, auto-disables when piped) ──────── USE_COLOR = sys.stdout.isatty() PURPLE, LILAC, DIM, RED, AMBER, GREEN = "38;5;141", "38;5;183", "38;5;244", "38;5;203", "38;5;179", "38;5;114" def paint(text: str, code: str) -> str: return f"\033[{code}m{text}\033[0m" if USE_COLOR else text def load_bars(ticker: str, *, period: str = "30d", interval: str = "5m") -> pd.DataFrame | None: """Default: yfinance only (typically delayed). Swap this to personalize.""" import yfinance as yf frame = yf.download(ticker, period=period, interval=interval, auto_adjust=False, progress=False, threads=False) if frame is None or frame.empty: return None if isinstance(frame.columns, pd.MultiIndex): frame.columns = frame.columns.get_level_values(0) frame = frame.rename(columns=str.lower) idx = pd.to_datetime(frame.index) idx = idx.tz_localize(ET, ambiguous="infer", nonexistent="shift_forward") if idx.tz is None else idx.tz_convert(ET) out = frame.copy() out.index = idx return out[["open", "high", "low", "close", "volume"]].astype(float).sort_index() def sessionize(bars: pd.DataFrame) -> pd.DataFrame: """Attach session_date + session_minute (0..390) + intraday cumulative volume.""" out = bars.copy() local = out.index.tz_convert(ET) minute = (local.hour * 60 + local.minute) - (9 * 60 + 30) out["session_date"] = local.date out["session_minute"] = minute rth = (minute >= 0) & (minute <= 390) & (local.weekday < 5) out = out[rth].copy() out["cum_volume"] = out.groupby("session_date")["volume"].cumsum() return out def same_clock_rvol_now(feats: pd.DataFrame, *, lookback: int, min_sessions: int) -> dict | None: """RVOL of the latest bar vs the same session-minute on prior sessions.""" if feats.empty: return None today = max(feats["session_date"]) today_rows = feats[feats["session_date"] == today].sort_values("session_minute") if today_rows.empty: return None last = today_rows.iloc[-1] minute = int(last["session_minute"]) prior = feats[(feats["session_date"] < today) & (feats["session_minute"] == minute)] prior = prior.sort_values("session_date").tail(lookback) n = int(prior["session_date"].nunique()) result = {"minute": minute, "n": n, "cum": float(last["cum_volume"]), "as_of": today_rows.index[-1]} mean = float(prior["cum_volume"].mean()) if n else 0.0 if n < min_sessions or mean <= 0: return {**result, "status": "LEARNING", "rvol": None} return {**result, "status": "AVAILABLE", "rvol": float(last["cum_volume"] / mean)} def clock(minute: int) -> str: total = 9 * 60 + 30 + minute return f"{total // 60:02d}:{total % 60:02d}" def state_of(rvol: float) -> tuple[str, str]: if rvol < 0.7: return "QUIET", DIM if rvol < 1.3: return "NORMAL", GREEN if rvol < 2.0: return "ELEVATED", AMBER return "EXTREME", RED _BLOCKS = " ▏▎▍▌▋▊▉█" def spark(rvol: float, *, vmax: float = 3.0, width: int = 12) -> str: frac = max(0.0, min(rvol / vmax, 1.0)) * width full = int(frac) body = "█" * full if full < width: body += _BLOCKS[int((frac - full) * 8)] + " " * (width - full - 1) return body[:width] def scan(watchlist: list[str], *, lookback: int, min_sessions: int) -> list[dict]: rows = [] for ticker in watchlist: try: bars = load_bars(ticker) except Exception as exc: # keep scanning the rest of the list rows.append({"ticker": ticker, "status": "ERROR", "note": str(exc)[:40], "rvol": None}) continue if bars is None or bars.empty: rows.append({"ticker": ticker, "status": "NO DATA", "rvol": None}) continue res = same_clock_rvol_now(sessionize(bars), lookback=lookback, min_sessions=min_sessions) rows.append({"ticker": ticker, **(res or {"status": "NO DATA", "rvol": None})}) return rows def render(rows: list[dict]) -> None: ranked = sorted(rows, key=lambda r: (r.get("rvol") is None, -(r.get("rvol") or 0))) stamps = [r["as_of"] for r in rows if r.get("as_of") is not None] as_of = max(stamps).strftime("%Y-%m-%d %H:%M ET") if stamps else "—" print() print(" " + paint("NEBULA", PURPLE) + paint(" · SAME-CLOCK RVOL SCANNER", LILAC) + paint(f" latest bar {as_of} · delayed", DIM)) print(paint(" " + "─" * 66, DIM)) print(paint(f" {'TICKER':<7}{'RVOL':>6} {'PACE':<12} {'STATE':<9}{'SESSION VOL':>15}", DIM)) for r in ranked: rvol = r.get("rvol") if rvol is None: note = r.get("status", "—") print(f" {r['ticker']:<7}{'—':>6} {' ' * 12} {paint(note, DIM):<9}") continue label, color = state_of(rvol) print(f" {r['ticker']:<7}{paint(f'{rvol:>5.2f}x', color)} " f"{paint(spark(rvol), color)} {paint(f'{label:<9}', color)}" f"{r['cum']:>15,.0f}") print(paint(" " + "─" * 66, DIM)) print(paint(" RVOL = today vs same-minute-of-day mean over prior sessions.", DIM)) print(paint(" Descriptive only · not investment advice · feed may be delayed.", DIM)) print() if __name__ == "__main__": import argparse p = argparse.ArgumentParser(description="Same-clock RVOL scanner (yfinance default; swap load_bars to personalize)") p.add_argument("tickers", nargs="*", help="override WATCHLIST, e.g. SPY QQQ NVDA") p.add_argument("--lookback", type=int, default=LOOKBACK_SESSIONS) p.add_argument("--min-sessions", type=int, default=MIN_SESSIONS) args = p.parse_args() universe = [t.upper() for t in args.tickers] or WATCHLIST render(scan(universe, lookback=args.lookback, min_sessions=args.min_sessions))
• Volume Curve Copy
  Plots today's cumulative-volume curve against the shape it usually traces by this time of day, with the normal 20–80% band. Opens a chart — run it and the curve appears. Needs matplotlib. #!/usr/bin/env python3 """Volume Curve — Nebula HQ Draw today's cumulative-volume curve against the shape it *usually* traces by this time of day. Hit play and a chart opens: today's path in Nebula purple, the expected curve (mean of prior sessions) dashed underneath, and the normal 20–80% band shaded. Above the band = leaning in early; below = asleep. expected(t) = mean cumulative volume at session-minute t over prior days band(t) = 20th–80th percentile of that same-clock distribution DEFAULT DATA FEED yfinance — free, typically ~15-minute delayed US equity data. Descriptive only. Not investment advice. PERSONALIZE Swap load_bars() for your broker / vendor / CSV. Keep columns open, high, low, close, volume and a timezone-aware index (ET preferred). pip install yfinance pandas matplotlib """ from __future__ import annotations import sys from zoneinfo import ZoneInfo import matplotlib.pyplot as plt import numpy as np import pandas as pd from matplotlib.ticker import FuncFormatter ET = ZoneInfo("America/New_York") # Print dashes / unicode cleanly even on a legacy Windows (cp1252) console. try: sys.stdout.reconfigure(encoding="utf-8") except (AttributeError, ValueError): pass # ── Nebula chart palette ────────────────────────────────────────────────────── BG, INK, DIM = "#0a0a0f", "#e8e6f0", "#8a86a0" PURPLE, LILAC, MUTED, BAND = "#a06bff", "#c9a6ff", "#6b6890", "#7a4bff" def load_bars(ticker: str, *, period: str = "30d", interval: str = "5m") -> pd.DataFrame: """Default: yfinance only (typically delayed). Swap this to personalize.""" import yfinance as yf frame = yf.download(ticker, period=period, interval=interval, auto_adjust=False, progress=False, threads=False) if frame is None or frame.empty: raise RuntimeError(f"no bars for {ticker} (delayed feed may be empty off-hours)") if isinstance(frame.columns, pd.MultiIndex): frame.columns = frame.columns.get_level_values(0) frame = frame.rename(columns=str.lower) idx = pd.to_datetime(frame.index) idx = idx.tz_localize(ET, ambiguous="infer", nonexistent="shift_forward") if idx.tz is None else idx.tz_convert(ET) out = frame.copy() out.index = idx return out[["open", "high", "low", "close", "volume"]].astype(float).sort_index() def sessionize(bars: pd.DataFrame) -> pd.DataFrame: out = bars.copy() local = out.index.tz_convert(ET) minute = (local.hour * 60 + local.minute) - (9 * 60 + 30) out["session_date"] = local.date out["session_minute"] = minute rth = (minute >= 0) & (minute <= 390) & (local.weekday < 5) out = out[rth].copy() out["cum_volume"] = out.groupby("session_date")["volume"].cumsum() return out def expected_curve(feats: pd.DataFrame, *, exclude_date, min_sessions: int = 5) -> pd.DataFrame | None: """Mean + 20/80 band of cumulative volume by session-minute across prior days.""" data = feats[feats["session_date"] != exclude_date] if data["session_date"].nunique() < min_sessions: return None g = data.groupby("session_minute")["cum_volume"] return pd.DataFrame({"mean": g.mean(), "lo": g.quantile(0.20), "hi": g.quantile(0.80)}).sort_index() def _theme() -> None: plt.rcParams.update({ "figure.facecolor": BG, "axes.facecolor": BG, "savefig.facecolor": BG, "axes.edgecolor": "#2a2740", "axes.labelcolor": "#c9c6d8", "text.color": INK, "xtick.color": DIM, "ytick.color": DIM, "grid.color": "#1c1a28", "font.family": "monospace", "axes.titleweight": "bold", }) def plot_curve(ticker: str, feats: pd.DataFrame): today = max(feats["session_date"]) base = expected_curve(feats, exclude_date=today) trow = feats[feats["session_date"] == today].sort_values("session_minute") if base is None or trow.empty: print(f"LEARNING — need >=5 prior sessions of {ticker} to draw the expected curve.") return None xb = base.index.to_numpy() xt, yt = trow["session_minute"].to_numpy(), trow["cum_volume"].to_numpy() ref = float(np.interp(xt[-1], xb, base["mean"].to_numpy())) ratio = yt[-1] / ref if ref > 0 else float("nan") print(f"{ticker} · {clock(int(xt[-1]))} ET — tracking {ratio:.2f}x the normal volume curve.") _theme() fig, ax = plt.subplots(figsize=(11, 6)) ax.fill_between(xb, base["lo"], base["hi"], color=BAND, alpha=0.13, lw=0, label="normal range (20–80%)") ax.plot(xb, base["mean"], color=MUTED, lw=1.6, ls="--", label="expected (avg prior sessions)") ax.plot(xt, yt, color=PURPLE, lw=2.6, label=f"{ticker} — {today}") ax.plot(xt[-1:], yt[-1:], marker="o", ms=7, color=LILAC, zorder=5) ax.annotate(f"{ratio:.2f}x", (xt[-1], yt[-1]), textcoords="offset points", xytext=(10, -4), color=LILAC, fontsize=11, fontweight="bold") ticks = list(range(0, 391, 60)) ax.set_xticks(ticks) ax.set_xticklabels([clock(m) for m in ticks]) ax.set_xlim(0, 390) ax.set_ylim(bottom=0) ax.yaxis.set_major_formatter(FuncFormatter(lambda v, _: f"{v / 1e6:.0f}M" if v >= 1e6 else f"{v:,.0f}")) ax.set_ylabel("cumulative session volume") ax.set_title(f"{ticker.upper()} · SAME-CLOCK VOLUME CURVE", color=LILAC, loc="left", pad=12) ax.grid(True, alpha=0.4, lw=0.6) ax.legend(loc="upper left", frameon=False, fontsize=9, labelcolor=INK) ax.text(0.995, 0.02, "NEBULA · descriptive · not investment advice", transform=ax.transAxes, ha="right", va="bottom", color=DIM, fontsize=8, alpha=0.75) fig.tight_layout() out = f"{ticker.lower()}_volume_curve.png" fig.savefig(out, dpi=130) print(f"saved {out}") plt.show() return fig def clock(minute: int) -> str: total = 9 * 60 + 30 + minute return f"{total // 60:02d}:{total % 60:02d}" if __name__ == "__main__": import argparse p = argparse.ArgumentParser(description="Volume curve chart (yfinance default; swap load_bars to personalize)") p.add_argument("ticker", nargs="?", default="SPY") p.add_argument("--period", default="30d") p.add_argument("--interval", default="5m") args = p.parse_args() bars = load_bars(args.ticker, period=args.period, interval=args.interval) plot_curve(args.ticker.upper(), sessionize(bars))
• Session Volume Heatmap Copy
  Session x time-block heatmap of same-clock RVOL for one name (yfinance default). #!/usr/bin/env python3 """Session Volume Heatmap — Nebula HQ A "volume clock" for one name. Hit play and a heatmap opens: each row is a recent session, each column a 30-minute block of the day, and the color is that block's same-clock RVOL — how heavy volume was versus the same block on other days. Bright cells are when this name lights up; you can read the open surge, the lunch lull, and the closing ramp straight off the grid. cell(day, t) = cumulative volume for `day` at block t ------------------------------------------------------ mean cumulative volume at block t over the *other* days DEFAULT DATA FEED yfinance — free, typically ~15-minute delayed US equity data. Descriptive only. Not investment advice. PERSONALIZE Swap load_bars() for your broker / vendor / CSV. Keep columns open, high, low, close, volume and a timezone-aware index (ET preferred). pip install yfinance pandas matplotlib """ from __future__ import annotations import sys from zoneinfo import ZoneInfo import matplotlib.pyplot as plt import numpy as np import pandas as pd from matplotlib.colors import LinearSegmentedColormap ET = ZoneInfo("America/New_York") # Print dashes / unicode cleanly even on a legacy Windows (cp1252) console. try: sys.stdout.reconfigure(encoding="utf-8") except (AttributeError, ValueError): pass # ── Nebula heatmap palette: near-black → deep violet → purple → soft white ──── BG, INK, DIM = "#0a0a0f", "#e8e6f0", "#8a86a0" NEBULA_CMAP = LinearSegmentedColormap.from_list( "nebula", ["#0a0a0f", "#221a3a", "#4a2ba0", "#a06bff", "#ecdcff"] ) DISPLAY_SESSIONS = 15 BLOCK_MINUTES = 30 def load_bars(ticker: str, *, period: str = "40d", interval: str = "5m") -> pd.DataFrame: """Default: yfinance only (typically delayed). Swap this to personalize.""" import yfinance as yf frame = yf.download(ticker, period=period, interval=interval, auto_adjust=False, progress=False, threads=False) if frame is None or frame.empty: raise RuntimeError(f"no bars for {ticker} (delayed feed may be empty off-hours)") if isinstance(frame.columns, pd.MultiIndex): frame.columns = frame.columns.get_level_values(0) frame = frame.rename(columns=str.lower) idx = pd.to_datetime(frame.index) idx = idx.tz_localize(ET, ambiguous="infer", nonexistent="shift_forward") if idx.tz is None else idx.tz_convert(ET) out = frame.copy() out.index = idx return out[["open", "high", "low", "close", "volume"]].astype(float).sort_index() def sessionize(bars: pd.DataFrame) -> pd.DataFrame: out = bars.copy() local = out.index.tz_convert(ET) minute = (local.hour * 60 + local.minute) - (9 * 60 + 30) out["session_date"] = local.date out["session_minute"] = minute rth = (minute >= 0) & (minute <= 390) & (local.weekday < 5) out = out[rth].copy() out["cum_volume"] = out.groupby("session_date")["volume"].cumsum() return out def rvol_grid(feats: pd.DataFrame, *, block: int = BLOCK_MINUTES) -> pd.DataFrame: """Leave-one-out same-clock RVOL per session (rows) and 30-min block (cols).""" grid = feats.pivot_table(index="session_date", columns="session_minute", values="cum_volume", aggfunc="last").sort_index() if grid.empty or grid.columns.empty: return pd.DataFrame() # Bridge only isolated single-bar gaps. Never fill a partial session's # un-traded tail — that would fake a low afternoon RVOL for today and leak # a stale cumulative into everyone else's same-clock baseline. grid = grid.ffill(axis=1, limit=1) targets = list(range(0, 391, block)) cols = sorted({min(grid.columns, key=lambda c: abs(c - t)) for t in targets}) grid = grid[cols] col_sum, col_cnt = grid.sum(axis=0), grid.count(axis=0) loo_mean = (col_sum - grid).div((col_cnt - 1).replace(0, np.nan), axis=1) return grid / loo_mean def clock(minute: int) -> str: total = 9 * 60 + 30 + minute return f"{total // 60:02d}:{total % 60:02d}" def _theme() -> None: plt.rcParams.update({ "figure.facecolor": BG, "axes.facecolor": BG, "savefig.facecolor": BG, "axes.edgecolor": "#2a2740", "text.color": INK, "xtick.color": DIM, "ytick.color": DIM, "font.family": "monospace", "axes.titleweight": "bold", }) def plot_heatmap(ticker: str, feats: pd.DataFrame): ratio = rvol_grid(feats) if ratio.dropna(how="all").shape[0] < 5: print(f"LEARNING — need >=5 prior sessions of {ticker} to build the heatmap.") return None disp = ratio.tail(DISPLAY_SESSIONS).iloc[::-1] # most recent session on top hottest = disp.stack() if not hottest.empty: (day, minute), val = hottest.idxmax(), hottest.max() print(f"{ticker} — hottest block: {day} {clock(int(minute))} ET at {val:.2f}x same-clock volume.") _theme() fig, ax = plt.subplots(figsize=(11, 6)) im = ax.imshow(disp.to_numpy(), cmap=NEBULA_CMAP, aspect="auto", vmin=0.4, vmax=2.2) ax.set_xticks(range(len(disp.columns))) ax.set_xticklabels([clock(int(m)) for m in disp.columns], rotation=45, ha="right", fontsize=8) ax.set_yticks(range(len(disp.index))) ax.set_yticklabels([str(d) for d in disp.index], fontsize=8) ax.set_title(f"{ticker.upper()} · SESSION VOLUME HEATMAP (same-clock RVOL)", color="#c9a6ff", loc="left", pad=12) cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.02) cbar.set_label("RVOL vs same-clock norm", color=DIM, fontsize=9) cbar.ax.yaxis.set_tick_params(color=DIM) plt.setp(cbar.ax.get_yticklabels(), color=DIM) ax.text(0.995, -0.14, "NEBULA · descriptive · not investment advice", transform=ax.transAxes, ha="right", va="top", color=DIM, fontsize=8, alpha=0.75) fig.tight_layout() out = f"{ticker.lower()}_volume_heatmap.png" fig.savefig(out, dpi=130) print(f"saved {out}") plt.show() return fig if __name__ == "__main__": import argparse p = argparse.ArgumentParser(description="Session volume heatmap (yfinance default; swap load_bars to personalize)") p.add_argument("ticker", nargs="?", default="SPY") p.add_argument("--period", default="40d") p.add_argument("--interval", default="5m") args = p.parse_args() bars = load_bars(args.ticker, period=args.period, interval=args.interval) plot_heatmap(args.ticker.upper(), sessionize(bars))