LTHB & HTLB Zones with AlertsIn price action trading, the Lowest Tick of the Highest Bar (LTHB) and the Highest Tick of the Lowest Bar (HTLB) are important concepts for support/resistance identification, trend exhaustion, and reversal confirmation. Here's what they mean and why they matter:
🔹 Definitions
1. Lowest Tick of the Highest Bar (LTHB):
The lowest price (tick) of the bar (candlestick) with the highest high in a recent price swing.
Significance: It marks the support inside an upward swing. If price breaks below this, it often indicates loss of upward momentum or reversal.
2. Highest Tick of the Lowest Bar (HTLB):
The highest price of the bar with the lowest low in a swing.
Significance: It acts as a resistance inside a downward swing. If price moves above this, it can signal a bullish reversal.
🔸 Why Are They Significant?
Concept LTHB HTLB
Trend Reversal - Break below LTHB → possible bearish reversal Break above HTLB → possible bullish reversal
Swing Confirmation -Holding above LTHB → continuation of uptrend Holding below HTLB → continuation of downtrend
Trap Detection - Stop hunts often occur just below LTHB Stop hunts often occur just above HTLB
Risk Management -Acts as logical stop-loss in long trades Acts as logical stop-loss in short trades
🔸 Uses in Strategy
1. Breakout Traders use these levels as entry triggers.
2. Reversal Traders look for price failing to hold these levels for early reversal signs.
3. Structure-Based Traders use them to confirm higher highs/lower lows.
4. Stop Placement: Tight stops just beyond LTHB/HTLB help manage risk in swing trades.
🔔 How to Set Alerts in TradingView:
Add the script to your chart.
Open the "⚠️ Alerts" tab.
Click "Create Alert".
In the "Condition" dropdown, select one of:
Enter LTHB Zone
Exit LTHB Zone
Enter HTLB Zone
Exit HTLB Zone
Set desired alert frequency (e.g., once per bar or once).
Click Create.
Indicators and strategies
Volume PercentileThis Pine Script indicator highlights bars where the current volume exceeds a configurable percentile threshold (e.g., 80th percentile) based on a rolling window of historical volume data.
🔍 Key Features:
Calculates a user-defined volume percentile (e.g., 75th, 80th, 90th) over a rolling window.
Marks candles where current volume is higher than the selected percentile.
Helps detect volume spikes, breakouts, or unusual activity.
Works directly on the main chart window for easier analysis.
🛠️ Inputs:
Window Length: Number of bars used to calculate the percentile (default = 20).
Percentile: The percentile threshold to trigger a high-volume signal (default = 80).
🖥️ Visualization:
Displays a red triangle marker below bars with volume above the selected percentile.
Weekend Background Highlighter (UTC+12)## Weekend Background Highlighter (UTC+12)
### Description
This indicator automatically highlights weekend periods on your TradingView charts specifically for the UTC+12 timezone (New Zealand Standard Time). Perfect for traders who need to visualize market closures and weekend gaps in the New Zealand/Pacific time zone, regardless of their exchange's native timezone or chart settings.
### Key Features
- **Fixed UTC+12 Timezone**: Hardcoded to always show weekends according to UTC+12, independent of exchange or chart timezone settings
- **Customizable Appearance**: Adjust background color and opacity to match your chart theme
- **Optional Weekend Labels**: Mark the beginning of each weekend period with customizable labels
- **Debug Mode**: View real-time timezone calculations to verify correct weekend detection
- **Lightweight**: Minimal performance impact with efficient calculations
### Use Cases
- **Forex Traders**: Identify weekend gaps and Monday openings in NZD pairs
- **Cryptocurrency Traders**: Visualize weekend trading patterns in the Pacific timezone
- **Multi-Market Traders**: Maintain consistent weekend awareness across different exchanges
- **Risk Management**: Clearly see when markets are closed for position management
### Settings
- **Weekend Background Color**: Choose any color for the weekend highlight
- **Opacity**: Control transparency (0-100%) to maintain chart visibility
- **Show Weekend Labels**: Toggle labels marking weekend start
- **Debug Info**: Display timezone calculations for verification
### How It Works
The indicator calculates the current UTC time and adds 12 hours to determine the UTC+12 time. It then checks if the resulting day falls on Saturday or Sunday, highlighting these periods on your chart. This ensures weekends are always displayed according to New Zealand time, regardless of your broker's timezone or your local settings.
### Notes
- Weekends begin at 00:00 Saturday UTC+12 (12:00 Friday UTC)
- Weekends end at 00:00 Monday UTC+12 (12:00 Sunday UTC)
- Works on all timeframes and markets
- Compatible with Pine Script v6
### Tags
weekend, background, timezone, UTC+12, New Zealand, highlight, trading sessions, forex, crypto, time zones, market hours, pacific time
Market Sell-Off GaugeOVERVIEW
The Market Sell‑Off Gauge identifies high‑conviction, risk‑off entry opportunities by detecting broad market sell‑off behavior and rising stablecoin dominance, then confirming risk‑off sentiment via NDX weakness, VIX spikes, and elevated volume. It uses fuzzy logic and sigmoid scaling to convert raw signals into a smooth, bounded metric.
FEATURES
Sell‑Off Detection - calculates percentage drops in the primary asset over a user‑defined lookback.
Stablecoin Dominance Surge - tracks combined USDT/USDC dominance rises as a proxy for on‑chain “flight to safety.”
Macro Confirmation
NDX Weakness (NASDAQ‑100)
VIX Spikes (CBOE Volatility Index)
Elevated Volume on declining bars
Fuzzy Logic & Scaling - component values feed into a fuzzy‑logic membership scor and are passed through a sigmoid compressor (–1 to +1). Weighted aggregation derives the final result of the gauge (or metric).
VISUALISATION
Continuous line plot - Smoothed metric (–1 to +1), colored cold‑to‑warm.
Entry circles - Highlighted when all conditions (fuzzy or crisp) are met after the time offset.
Time‑Offset marker - Vertical line/label showing the user‑specified “start” bar.
Component table - Displays real‑time % changes & volume multiples in the lower right of the indicator.
USAGE
Asset drop % - The threshold percent decline to register a sell‑off.
Stables rise % - The threshold percent increase in stablecoin dominance to qualify as a “flight to safety.”
NDX drop % - The threshold percent decline in the NASDAQ‑100 for macro confirmation.
VIX rise % - The threshold percent increase in VIX. Contributes to risk‑off validation.
Volume Multiplier - Defines how many times above SMA volume must rise to confirm conviction.
Lookback Period - Controls the number of bars over which % changes are measured.
Time Offset - Point in time beyond which bars to “fade” historical signals, enables focus on recent data only.
Fuzzy Logic Settings - Enables fuzzy scoring and set membership threshold & sensitivity.
Weights - allows for adjusting the relative importance of each component (Asset, Stables, NDX, VIX, Volume).
Sigmoid Steepness (k) - Controls curve steepness for compression (0.1 = very flat → 5.0 = very sharp S‑curve).
Chart & settings
Best applied on 4H or Daily BTCUSD (or similar) charts to capture meaningful sell‑off events.
Combine with broader trend filters (e.g., moving averages) for trend‑aligned entries.
Adjust Sigmoid Steepness and Membership Sensitivity to fine‑tune signal crispness vs. smoothness. Refer to tooltips.
Disclaimer
This indicator is intended for educational purposes only. Always perform your own due diligence before making financial decisions.
OBV with MA & Bollinger Bands by Marius1032OBV with MA & Bollinger Bands by Marius1032
This script adds customizable moving averages and Bollinger Bands to the classic OBV (On Balance Volume) indicator. It helps identify volume-driven momentum and trend strength.
Features:
OBV-based trend tracking
Optional smoothing: SMA, EMA, RMA, WMA, VWMA
Optional Bollinger Bands with SMA
Potential Combinations and Trading Strategies:
Breakouts: Look for price breakouts from the Bollinger Bands, and confirm with a rising OBV for an uptrend or falling OBV for a downtrend.
Trend Reversals: When the price touches a Bollinger Band, examine the OBV for divergence. A bullish divergence (price lower low, OBV higher low) near the lower band could signal a reversal.
Volume Confirmation: Use OBV to confirm the strength of the trend indicated by Bollinger Bands. For example, if the BBs indicate an uptrend and OBV is also rising, it reinforces the bullish signal.
1. On-Balance Volume (OBV):
Purpose: OBV is a momentum indicator that uses volume flow to predict price movements.
Calculation: Volume is added on up days and subtracted on down days.
Interpretation: Rising OBV suggests potential upward price movement. Falling OBV suggests potential lower prices.
Divergence: Divergence between OBV and price can signal potential trend reversals.
2. Moving Average (MA):
Purpose: Moving Averages smooth price fluctuations and help identify trends.
Combination with OBV: Pairing OBV with MAs helps confirm trends and identify potential reversals. A crossover of the OBV line and its MA can signal a trend reversal or continuation.
3. Bollinger Bands (BB):
Purpose: BBs measure market volatility and help identify potential breakouts and trend reversals.
Structure: They consist of a moving average (typically 20-period) and two standard deviation bands.
Combination with OBV: Combining BBs with OBV allows for a multifaceted approach to market analysis. For example, a stock hitting the lower BB with a rising OBV could indicate accumulation and a potential upward reversal.
Created by: Marius1032
Killzones [Plug&Play]Highlight the most important institutional trading hours with precision.
The Setup Agent Killzones indicator automatically plots vertical lines to mark the key “Killzone” windows each day — London (08:00–09:00) and New York (15:00–16:00), shown in UK time. These timeframes represent periods of high volatility, where smart money activity is most likely to create the day’s major moves.
How it works:
Instantly visualise the London and New York Killzones with subtle vertical lines.
Customise which sessions to show to fit your trading style.
Stay focused on the windows where market makers are most active.
Perfect for intraday traders and anyone using session-based strategies.
Combine with our session indicator for a complete Plug&Play edge.
Long-Leg Doji Breakout StrategyThe Long-Leg Doji Breakout Strategy is a sophisticated technical analysis approach that capitalizes on market psychology and price action patterns.
Core Concept: The strategy identifies Long-Leg Doji candlestick patterns, which represent periods of extreme market indecision where buyers and sellers are in equilibrium. These patterns often precede significant price movements as the market resolves this indecision.
Pattern Recognition: The algorithm uses strict mathematical criteria to identify authentic Long-Leg Doji patterns. It requires the candle body to be extremely small (≤0.1% of the total range) while having long wicks on both sides (at least 2x the body size). An ATR filter ensures the pattern is significant relative to recent volatility.
Trading Logic: Once a Long-Leg Doji is identified, the strategy enters a "waiting mode," monitoring for a breakout above the doji's high (long signal) or below its low (short signal). This confirmation approach reduces false signals by ensuring the market has chosen a direction.
Risk Management: The strategy allocates 10% of equity per trade and uses a simple moving average crossover for exits. Visual indicators help traders understand the pattern identification and trade execution process.
Psychological Foundation: The strategy exploits the natural market cycle where uncertainty (represented by the doji) gives way to conviction (the breakout), creating high-probability trading opportunities.
The strength of this approach lies in its ability to identify moments when market sentiment shifts from confusion to clarity, providing traders with well-defined entry and exit points while maintaining proper risk management protocols.
How It Works
The strategy operates on a simple yet powerful principle: identify periods of market indecision, then trade the subsequent breakout when the market chooses direction.
Step 1: Pattern Detection
The algorithm scans for Long-Leg Doji candles, which have three key characteristics:
Tiny body (open and close prices nearly equal)
Long upper wick (significant rejection of higher prices)
Long lower wick (significant rejection of lower prices)
Step 2: Confirmation Wait
Once a doji is detected, the strategy doesn't immediately trade. Instead, it marks the high and low of that candle and waits for a definitive breakout.
Step 3: Trade Execution
Long Entry: When price closes above the doji's high
Short Entry: When price closes below the doji's low
Step 4: Exit Strategy
Positions are closed when price crosses back through a 20-period moving average, indicating potential trend reversal.
Market Psychology Behind It
A Long-Leg Doji represents a battlefield between bulls and bears that ends in a stalemate. The long wicks show that both sides tried to push price in their favor but failed. This creates a coiled spring effect - when one side finally gains control, the move can be explosive as trapped traders rush to exit and momentum traders jump aboard.
Key Parameters
Doji Body Threshold (0.1%): Ensures the body is truly small relative to the candle's range
Wick Ratio (2.0): Both wicks must be at least twice the body size
ATR Filter: Uses Average True Range to ensure the pattern is significant in current market conditions
Position Size: 10% of equity per trade for balanced risk management
Pros:
High Probability Setups: Doji patterns at key levels often lead to significant moves as they represent genuine shifts in market sentiment.
Clear Rules: Objective criteria for entry and exit eliminate emotional decision-making and provide consistent execution.
Risk Management: Built-in position sizing and exit rules help protect capital during losing trades.
Market Neutral: Works equally well for long and short positions, adapting to market direction rather than fighting it.
Visual Confirmation: The strategy provides clear visual cues, making it easy to understand when patterns are forming and trades are triggered.
Cons:
False Breakouts: In choppy or ranging markets, price may break the doji levels only to quickly reverse, creating whipsaws.
Patience Required: Traders must wait for both pattern formation and breakout confirmation, which can test discipline during active market periods.
Simple Exit Logic: The moving average exit may be too simplistic, potentially cutting profits short during strong trends or holding losers too long during reversals.
Volatility Dependent: The strategy relies on sufficient volatility to create meaningful doji patterns - it may underperform in extremely quiet markets.
Lagging Entries: Waiting for breakout confirmation means missing the very beginning of moves, reducing potential profit margins.
Best Market Conditions
The strategy performs optimally during periods of moderate volatility when markets are making genuine directional decisions rather than just random noise. It works particularly well around key support/resistance levels where the market's indecision is most meaningful.
Optimization Considerations
Consider combining with additional confluence factors like volume analysis, support/resistance levels, or other technical indicators to improve signal quality. The exit strategy could also be enhanced with trailing stops or multiple profit targets to better capture extended moves while protecting gains.
Best for Index option,
Enjoy !!
Faster Heikin AshiFaster Heikin Ashi
The Faster Heikin Ashi improves traditional Heikin Ashi candles by introducing advanced weighting mechanisms and lag reduction techniques. While maintaining the price smoothing benefits of standard Heikin Ashi, this enhanced version delivers faster signals and responsiveness.
Key Features
Unified Responsiveness Control
Single parameter (0.1 - 1.0) controls all responsiveness aspects
Eliminates conflicting settings found in other enhanced HA indicators
Intuitive scaling from conservative (0.1) to highly responsive (1.0)
Advanced Weighted Calculations
Smart Close Weighting: Close prices receive 2-3x more influence for faster trend detection
Dynamic OHLC Processing: All price components are intelligently weighted based on responsiveness setting
Balanced High/Low Emphasis: Maintains price level accuracy while improving speed
Enhanced Open Calculation
Transition Speed: Open prices "catch up" to market movements faster
Lag Reduction Algorithm: Eliminates the typical delay in Heikin Ashi open calculations
Smooth Integration: Maintains visual continuity while improving responsiveness
Four-Color Scheme
- 🟢 **Lime**: Strong bullish momentum
- 🔴 **Red**: Strong bearish momentum
- 🟢 **Green**: Moderate bullish
- 🔴 **Maroon**: Moderate bearish
How It Works
Traditional Heikin Ashi smooths price action but often lags behind real market movements. This enhanced version:
1. Weights price components based on their predictive value
2. Accelerates trend transitions through advanced open calculations
3. Scales all enhancements through a single responsiveness parameter
4. Maintains smoothing benefits while reducing lag
Responsiveness (0.1 - 1.0)
0.1 - 0.3: Conservative, maximum smoothing
0.4 - 0.6: Balanced, good for swing trading and trend following
0.7 - 1.0: Aggressive, fast signals, suitable for scalping and active trading
Flux Capacitor (FC)# Flux Capacitor
**A volume-weighted, outlier-resistant momentum oscillator designed to expose hidden directional pressure from institutional participants.**
---
### Why "Flux Capacitor"?
The name pays homage to the fictional energy core in *Back to the Future* — an invisible engine that powers movement. Similarly, this indicator detects whether price movement is being powered by real market participation (volume) or if it's coasting without conviction.
---
### Methodology
The Flux Capacitor fuses three statistical layers:
- **Normalized Momentum**: `(Close – Open) / ATR`
Controls for raw price size and volatility.
- **Volume Scaling**:
Amplifies the effect of price moves that occur with elevated volume.
- **Robust Normalization**:
- *Winsorization* caps outlier spikes.
- *MAD-Z scoring* normalizes the signal across assets (crypto, futures, stocks).
- This produces consistent scaling across timeframes and symbols.
The result is a smooth oscillator that reliably indicates **liquidity-backed momentum** — not just price movement.
---
### Signal Events
- **Divergence (D)**: Price makes higher highs or lower lows, but Flux does not.
- **Absorption (A)**: Candle shows high volume and small body, while Flux opposes the candle direction — indicates smart money stepping in.
- **Compression (◆)**: High volume with low momentum — potential breakout zone.
- **Zero-Cross**: Indicates directional regime flip.
- **Flux Acceleration**: Histogram shows pressure rate of change.
- **Regime Background**: Color fades with weakening trend conviction.
All signals are color-coded and visually compact for easy pattern recognition.
---
### Interpreting Divergence & Absorption Correctly
Signal strength improves significantly when it appears **in the correct zone**:
#### Divergence:
| Signal | Zone | Meaning | Strength |
|--------|------------|------------------------------------------|--------------|
| Green D | Below 0 | Bullish reversal forming in weakness | **Strong** |
| Green D | Above 0 | Bullish, but less convincing | Moderate |
| Red D | Above 0 | Bearish reversal forming in strength | **Strong** |
| Red D | Below 0 | Bearish continuation — low warning value | Weak |
#### Absorption:
| Signal | Zone | Meaning | Strength |
|--------|------------|-----------------------------------------|--------------|
| Green A | Below 0 | Buyers absorbing panic-selling | **Strong** |
| Green A | Above 0 | Support continuation | Moderate |
| Red A | Above 0 | Sellers absorbing FOMO buying | **Strong** |
| Red A | Below 0 | Trend continuation — not actionable | Weak |
Look for **absorption or divergence signals in “enemy territory”** for the most actionable entries.
---
### Reducing Visual Footprint
If your chart shows a long line of numbers across the top of the Flux Capacitor pane (e.g. "FC 14 20 9 ... Bottom Right"), it’s due to TradingView’s *status line input display*.
**To fix this**:
Right-click the indicator pane → **Settings** → **Status Line** tab → uncheck “Show Indicator Arguments”.
This frees up vertical space so top-edge signals (like red `D` or yellow `◆`) remain visible and unobstructed.
---
### Features
- Original MAD-Z based momentum design
- True volume-based divergence and absorption logic
- Built-in alerts for all signal types
- Works across timeframes (1-min to weekly)
- Minimalist, responsive layout
- 25+ customizable parameters
- No future leaks, no repainting
---
### Usage Scenarios
- **Trend confirmation**: Flux > 0 confirms bullish trend strength
- **Reversal detection**: Divergence or absorption in opposite territory = high-probability reversal
- **Breakout anticipation**: Compression signal inside range often precedes directional move
- **Momentum shifts**: Watch for zero-crosses + flux acceleration spikes
---
### ⚠ Visual Note for BTC, ETH, Crude Oil & Futures
These high-priced or rapidly accelerating instruments can visually compress any linear oscillator. You may notice the Flux Capacitor’s line appears "flat" or muted on these assets — especially over long lookbacks.
> **This does not affect signal validity.** Divergence, absorption, and compression triggers still fire based on underlying logic — only the line’s amplitude appears reduced due to scaling constraints.
---
### Disclaimer
This indicator is for educational purposes only. It is not trading advice. Past results do not guarantee future performance. Use in combination with your own risk management and analysis.
[TupTrader] Multi-Timeframe Key Levels | Smart Candle Zones
**Multi-Timeframe Key Levels | Smart Candle Zones**
Unlock the power of smart price levels with Multi-Timeframe Key Levels – a precision tool for traders who rely on higher timeframe structure.
🧠 This indicator automatically plots the key levels (Open, High, Low, Close) and optional body/fibonacci levels of the *previous candle* from two customizable higher timeframes, directly onto your lower timeframe chart.
💡 Recommended settings:
- 4H + Daily on 5-Minute Chart
- 8H + 1H on 1-Minute Chart
📈 Ideal for:
- Scalping around structure levels
- Day trading with HTF context
- Confirmation of breakout, retest, or rejection patterns
✅ Features:
- Dual reference timeframes
- Auto-adjusting line lengths
- Live price labels (e.g. H: 4321.50)
- Choice between body or Fibonacci zones
- Candle box visualization of HTF structure
🚨 Alerts:
- Alert when price touches any HTF key level
Lightweight and customizable, this tool is a must-have for intraday and structure-based traders.
ATR-Multiple from 50SMAThis indicator provides a nuanced view of price extension by calculating the distance between the current price and its 50-period Simple Moving Average. This distance is not measured in simple percentage terms but is quantified in multiples of the Average True Range (ATR), offering a volatility-adjusted perspective on how far an asset has moved from its mean.
The primary goal is to help traders identify potentially overextended conditions, which can often precede price consolidation or reversals. As a general guideline, when an asset's price stretches to multiples of 7 ATRs or more above its 50-day SMA, it often enters a zone where significant profit-taking may occur. By visualizing this extension, the indicator can serve as a powerful tool for gauging when to consider taking profits on existing long positions. Furthermore, it can act as a cautionary signal, helping traders avoid initiating new long positions in assets that are already significantly stretched and may be poised for a pullback.
Features
Volatility-Adjusted Extension
Measures the distance from the 50 SMA in terms of ATR multiples, providing a more standardized way to compare extension across different assets and time periods.
Daily Timeframe Consistency
By default, the indicator uses the daily SMA and ATR for its calculations, regardless of the chart's current timeframe. This ensures a consistent and meaningful measure of extension rooted in the daily trend.
Histogram Visualization
Displays the result as a clear histogram in a separate pane, making it easy to track the extension level over time and identify historical extremes.
Dynamic Color-Coding
The histogram bars are color-coded to visually highlight different levels of extension. The colors shift as the price moves further from the mean, providing an intuitive at-a-glance reading.
Key Threshold Markers
Includes pre-set horizontal lines at the 7 and 10 ATR multiples to clearly mark the zones of potential profit-taking and extreme extension, respectively.
Built-in Alerts
Comes with configurable alert conditions that can notify you when the price reaches the "profit-taking" threshold (7 ATRs) or the "extreme extension" threshold (10 ATRs).
Customization Options
MA & ATR Periods
You can adjust the length for the Simple Moving Average (default 50) and the Average True Range (default 14) to suit your specific analytical needs.
Timeframe Source
A toggle allows you to switch between always calculating using daily data (the default and recommended setting) or using the data from the current chart's timeframe.
Color Display Style
You can choose between a smooth color gradient that transitions elegantly with the extension level or a distinct, step-based color display for a clearer visual separation of the defined zones.
Full Color Scheme Control
Every visual element is fully customizable. You can change the colors for the regular extension, the "get ready," "profit-taking," and "extreme" levels, as well as the horizontal reference lines.
HOG Liquidity HunterHOG Liquidity Hunter – Pivot‑Based Liquidity Zones
📌 Overview
Plots dynamic support and resistance zones on swing pivots with an ATR‑based buffer. Anchored only when pivots are confirmed, the zones stay close to current price levels—ideal for spotting liquidity runs or traps.
🔧 How It Works
Detects swing highs and lows using ta.pivothigh() / ta.pivotlow() with a user‑defined lookback.
After a pivot is confirmed, calculates BSL/SSL zone = pivot ± (ATR * margin).
Zones update only on confirmed pivots—no repainting on open bars.
⚙️ Inputs
Lookback: bars to confirm pivots (e.g. 10–20).
ATR Margin Multiplier: buffer width (e.g. 1.25).
✅ Benefits
Structure‑focused: Zones align with real swing points.
Responsive yet stable: Tight ATR margin keeps zones precise, only updating on valid pivots.
Clean visuals: Two uncluttered zones—easy to interpret.
🛠 How to Use
Detect near‑zone bounce entries or exits on 4H/1D charts.
Combine with trend or volume indicators for stronger setups.
Use zones to identify potential stop‑run, liquidity re‑tests, or range turns.
⚠️ Notes & Disclaimers
Zones base off historical pivots; may lag until confirmed.
No future-looking data—relying entirely on closing bar confirmation.
Use alongside a complete trading framework; this is not a standalone signal.
True Hour Open🧠 Why Count an Hour from 30th Minute to 30th Minute?
✅ Traditional Hour vs. Functional Hour
Traditional Time Logic: We’re used to viewing time in clean hourly chunks: 12:00 to 1:00, 1:00 to 2:00, and so on. This structure is fine for general purposes like clocks, meetings, and schedules.
Market Logic: Markets, however, don’t always respect these arbitrary human-made time divisions. Price action often develops momentum, structure, and transitions based on market participants' behavior, not on the clock.
🛠 What the Indicator Does
Marks the start of each hour at the 30th minute past the hour (e.g., 1:30, 2:30, 3:30).
Can highlight or segment candles that fall within a “30-to-30” hourly window.
Optionally draws background shading, lines, or boxes to visually group candles from one 30-minute mark to the next.
This helps you:
Visually align your trading with more accurate price behavior windows.
Anchor time blocks around actual market rhythm, not artificial time slots.
Backtest and strategize based on how candles behave in these alternative hourly segments.
📈 Summary
Trading is about timing. But great trading is about timing that makes sense.
By redefining the hour from 30 to 30, you’re not changing time—you’re aligning with how price moves in time.
Doji Signals with Wick ColorThis indicator identifies Doji candlestick patterns on the chart and highlights both the candle body and wicks in yellow for better visibility.
A Doji is defined as a candle where the body size is relatively small compared to the full range (high - low), indicating market indecision. You can adjust the maximum allowed body size as a percentage of the total candle range using the "Doji's Max Body Size" input.
The indicator works by:
Calculating the body size (abs(open - close))
Comparing it to a threshold (precision * (high - low))
Highlighting candles that meet the condition as Doji, coloring both the body and wick in yellow
This visual aid helps traders quickly spot potential reversal or pause areas in price action based on candlestick psychology.
Dynamic Flow Ribbons [BigBeluga]🔵 OVERVIEW
A dynamic multi-band trend visualization system that adapts to market volatility and reveals trend momentum with layered ribbon channels.
Dynamic Flow Ribbons transforms price action into flowing trend bands that expand and contract with volatility. It not only shows the active directional bias but also visualizes how strong or weak the trend is through layered ribbons, making it easier to assess trend quality and structure.
🔵 CONCEPTS
Uses an adaptive trend detection system built on a volatility envelope derived from an EMA of the average price (HLC3).
Measures volatility using a long-period average of the high-low range, which scales the envelope width dynamically.
Trend direction flips when the average price crosses above or below these envelopes.
Ribbons form around the trend line to show how far price is stretching or compressing relative to the mean.
🔵 FEATURES
Volatility-Based Trend Line:
A thick, color-coded line tracks the current trend with smoother transitions between phases.
Multi-Layered Flow Ribbons:
Up to 10 bands (5 above and 5 below) radiate outward from the upper and lower envelopes, reflecting volatility strength and direction.
Trend Coloring & Transitions:
Ribbons and candles are dynamically colored based on trend direction— green for bullish , orange for bearish . Transparency fades with distance from the core trend band.
Real-Time Responsiveness:
Ribbon structure and trend shifts update in real time, adapting instantly to fast market changes.
🔵 HOW TO USE
Use the color and thickness of the core trend line to follow directional bias.
When ribbons widen symmetrically, it signals strong trend momentum .
Narrowing or overlapping ribbons can suggest consolidation or transition zones .
Combine with breakout systems or volume tools to confirm impulsive or corrective phases .
Adjust the “Length” (factor) input to tune sensitivity—higher values smooth trends more.
🔵 CONCLUSION
Dynamic Flow Ribbons offers a sleek and insightful view into trend strength and structure. By visualizing volatility expansion with directional flow, it becomes a powerful overlay for momentum traders, swing strategists, and trend followers who want to stay ahead of evolving market flows
Setup Score OscillatorSetup Score Oscillator – Full Description
🎯 Purpose of the Script
This script is a manual trading setup scoring tool, designed to help traders quantify the quality of a trade setup by combining multiple technical, cyclical, and contextual signals.
Instead of relying on a single indicator, the trader manually selects which signals are present, and the script calculates a total score (0–100%), displayed as an oscillator in a separate panel (like RSI or MACD).
🔧 How it works in practice
1. Manual signal inputs
The script presents a set of checkboxes in the settings, where the trader can enable/disable the following signals:
✅ Confirmed Support/Resistance
✅ Aligned Volume Profile
✅ Favorable Cyclic Timing
✅ Valid Trend Line
✅ Aligned Cyclical Moving Averages
✅ Relevant Fibonacci Level
✅ Classic Volume Signal (spike, dry-up, etc.)
✅ Oscillator confirmation (e.g., divergences)
✅ Extreme Sentiment
✅ Relevant or incoming News
Each selected signal contributes to the total score based on its weight.
2. Scoring system
Each signal has a default weight (e.g., 20% for support/resistance, 15% for cycles, etc.).
Optionally, the trader can enable the “custom weights” checkbox and adjust each signal’s weight directly in the settings.
3. Score visualization
The final score (sum of all active weights) is plotted as an oscillator ranging from 0 to 100%, with dynamic coloring:
Range Color Meaning
0–39% Red No valid setup
40–54% Yellow Watchlist only
55–69% Orange Good setup
70–100% Green Strong setup
Several horizontal threshold lines are displayed:
50% → neutral threshold
40%, 55%, 70% → operational levels
4. Optional background coloring
When the score exceeds 55% or 70%, the oscillator background lightly changes color to highlight stronger setups (non-intrusive).
📌 Practical benefits
Objectifies subjective analysis: each decision becomes a number.
Prevents overtrading: no entries if the score is too low.
Adaptable to any trading style: swing, intraday, positional.
User-friendly: no coding needed – just tick boxes.
Italiano:
Setup Score Oscillator – Descrizione completa
🎯 Obiettivo dello script
Lo script è uno strumento manuale di valutazione dei setup di trading, pensato per aiutare il trader a quantificare la qualità di un'opportunità operativa basandosi su più segnali tecnici, ciclici e contestuali.
Invece di affidarsi a un solo indicatore, il trader seleziona manualmente quali segnali sono presenti, e lo script calcola un punteggio complessivo percentuale (0–100%), rappresentato come oscillatore in una finestra separata (tipo RSI, MACD, ecc.).
🔧 Come funziona operativamente
1. Input manuale dei segnali
Lo script mostra una serie di checkbox nelle impostazioni, dove il trader può attivare o disattivare i seguenti segnali:
✅ Supporto/Resistenza confermata
✅ Volume Profile allineato
✅ Cicli o timing favorevole
✅ Trend line valida
✅ Medie mobili cicliche allineate
✅ Livello di Fibonacci rilevante
✅ Volume classico significativo (spike, dry-up)
✅ Conferme da oscillatori (es. divergenze)
✅ Sentiment estremo (es. euforia o panico)
✅ News importanti imminenti o appena uscite
Ogni casella attiva contribuisce al punteggio totale, con un peso specifico.
2. Sistema di punteggio
Ogni segnale ha un peso predefinito (es. 20% per supporti/resistenze, 15% per cicli, ecc.).
Facoltativamente, il trader può attivare la funzione “Enable custom weights” per personalizzare i pesi di ciascun segnale direttamente da input.
3. Visualizzazione del punteggio
Il punteggio complessivo (somma dei pesi attivati) viene tracciato come oscillatore da 0 a 100%, con colori dinamici:
Range Colore Significato
0–39% Rosso Nessun setup valido
40–54% Giallo Osservazione
55–69% Arancione Setup buono
70–1005 Verde Setup forte
Sono tracciate anche delle linee guida orizzontali a:
50% → soglia neutra
40%, 55%, 70% → soglie operative
4. Colorazione dello sfondo (facoltativa)
Quando il punteggio supera 55% o 70%, lo sfondo dell’oscillatore cambia leggermente colore per evidenziare il segnale (non invasivo).
📌 Vantaggi pratici
Oggettivizza l’analisi soggettiva: ogni decisione manuale si trasforma in un numero.
Evita overtrading: se il punteggio è troppo basso, non si entra.
Adattabile a ogni stile: swing, intraday, position.
Facile da usare anche senza codice: basta spuntare le caselle.
Squeeze Pro Momentum BAR color - KLTDescription:
The Squeeze Pro Momentum indicator is a powerful tool designed to detect volatility compression ("squeeze" zones) and visualize momentum shifts using a refined color-based system. This script blends the well-known concepts of Bollinger Bands and Keltner Channels with an optimized momentum engine that uses dynamic color gradients to reflect trend strength, direction, and volatility.
It’s built for traders who want early warning of potential breakouts and clearer insight into underlying market momentum.
🔍 How It Works:
📉 Squeeze Detection:
This indicator identifies "squeeze" conditions by comparing Bollinger Bands and Keltner Channels:
When Bollinger Bands are inside Keltner Channels → Squeeze is ON
When Bollinger Bands expand outside Keltner Channels → Squeeze is OFF
You’ll see squeeze zones classified as:
Wide
Normal
Narrow
Each represents varying levels of compression and breakout potential.
⚡ Momentum Engine:
Momentum is calculated using linear regression of the price's deviation from a dynamic average of highs, lows, and closes. This gives a more accurate representation of directional pressure in the market.
🧠 Smart Candle Coloring (Optimized):
The momentum color logic is inspired by machine learning principles (no hardcoded thresholds):
EMA smoothing and rate of change (ROC) are used to detect momentum acceleration.
ATR-based filters help remove noise and false signals.
Colors are dynamically assigned based on both direction and trend strength.
🧪 How to Use It:
Look for Squeeze Conditions — especially narrow squeezes, which tend to precede high-momentum breakouts.
Confirm with Momentum Color — strong colors often indicate trend continuation; fading colors may signal exhaustion.
Combine with Price Action — use this tool with support/resistance or patterns for higher probability setups.
Recommended For:
Trend Traders
Breakout Traders
Volatility Strategy Users
Anyone who wants visual clarity on trend strength
📌 Tip: This indicator works great when layered with volume and price action patterns. It is fully non-repainting and supports overlay on price charts.
Disguised Candles by The School of Dalal StreetDisguised Candles corrects one of the subtle visual distortions present in normal candlestick charts — the mismatch between the close of one candle and the open of the next.
On many instruments (especially at day/session breaks), the next candle’s open often jumps due to price gaps or data feed behavior. This can make reading the flow of price action harder than necessary.
Disguised Candles fixes this by plotting synthetic candles where the open of each candle is forced to match the close of the previous one — creating a visually continuous flow of price.
Real candles are made fully transparent, so only the "corrected" candles are visible.
This allows traders to:
Visualize price flow as a smooth path
Better spot true directional shifts and trends
Avoid distractions caused by technical gaps that are not meaningful to their strategy
🚀 Pure visual clarity. No noise from false opens.
How it works:
The open of each synthetic candle = close of previous real candle
High, Low, Close remain unchanged
Colors are based on Close vs Corrected Open
Real chart candles are hidden under a transparent overlay
Use this as a clean canvas for trend analysis or as a foundation for building new visual systems.
Market Balance LevelMarket Balance Level (MBL)
This indicator dynamically identifies price consolidation zones (market balance levels) and plots a horizontal line at the average midpoint of the range once a valid breakout occurs. It helps traders visualize key zones where the market was previously in equilibrium and is likely to retest before continuing its trend.
How It Works:
Detects consolidation ranges using consecutive candles within a tight high-low structure.
When a breakout occurs (above or below the range), it plots a line at the average midpoint of the consolidation.
Triangles are drawn on breakouts to visually confirm the breakout direction.
Lines can be customized by color, width, and breakout direction (bullish, bearish, or both).
Recommended Use:
Wait for price to return to the Market Balance Level (MBL). These levels often act as strong support or resistance.
Enter upon engulfment (candle closes strongly in the direction of the breakout), confirming continuation.
Features:
Adjustable consolidation sensitivity and line length.
Option to show/hide bullish or bearish MBLs.
Visual breakout markers (triangles) with alert support.
Optional alert messages for breakout events.
Use this tool to enhance your structure-based or SMC-style trading strategies.
Differential-Isaac-Newton
Description of the Differential-Isaac-Newton Indicator (DF-Newton)
This indicator plots custom Fibonacci levels on the chart using configurable multiples and offers various display options to assist with technical analysis.
What does it do?
Calculates and plots Fibonacci levels based on user-defined multiples (default multiple is 20).
Allows switching between long mode (buy) and short mode (sell) to adjust the levels accordingly.
Displays horizontal lines at Fibonacci levels with customizable colors and styles.
Shows labels with different information such as level price, Fibonacci percentage, and difference between levels.
Includes controls to show/hide different elements and customize the appearance.
How to use it?
Main Settings
Multiple of 2 for Fibonacci: Defines the percentage interval used to calculate Fibonacci levels (e.g., 20 creates levels at 0%, 20%, 40%, etc.).
Line Horizontal Offset: Defines the horizontal distance (in bars) of the Fibonacci line to improve visibility.
Short Mode: Enable to calculate levels based on a downward movement (from low to high).
Classic Mode: Changes the line colors to a classic Fibonacci color scheme (blue, green, yellow, orange, red).
Toggle Solid Line: Switches between solid and dotted lines for Fibonacci levels.
Labels
Choose which information to display on the labels next to the lines:
Show Only Level Prices: Displays only the Fibonacci level price.
Show Only Level Percentages: Displays only the Fibonacci percentage level.
Show Difference Values (Δ): Shows the difference between the current and previous level, along with the percentage (which can be hidden).
Hide Percentage in Difference Mode: Hides the percentage when difference mode is enabled.
Hide All Labels: Hides all labels from the chart.
Visual Customization
Label Size: Size of the label text (XS, S, M, L).
Label Horizontal Offset: Horizontal distance of labels relative to the lines.
Background Offset: Adjusts background color offset for better visibility.
Fibonacci Line Color: Color of the Fibonacci lines (when classic mode is off).
Label Text Color: Color of the label text.
Level Interpretation
Fibonacci levels are calculated between the highest high and lowest low of the last 100 candles.
The indicator plots horizontal lines at Fibonacci levels according to the selected multiple.
Line colors help identify important levels (configurable in classic mode).
Labels show the exact level price and Fibonacci percentage, helping with entry, exit, support, and resistance decisions.
Recommendations
Use Short Mode to analyze Fibonacci levels for sell trades.
Use Classic Mode for a traditional color scheme and easier identification.
Adjust Line Horizontal Offset to avoid overlapping current candles.
Combine price and percentage display for easier analysis.
Explore Difference Mode (Δ) to understand gaps between consecutive Fibonacci levels.
Practical Example
If you set the multiple to 20, the indicator will show levels at 0%, 20%, 40%, 60%, 80%, and 100%. Each level will have a horizontal line and a label showing the corresponding price and percentage, or the difference from the previous level, depending on your settings.
Volatility Quality [Alpha Extract]The Alpha-Extract Volatility Quality (AVQ) Indicator provides traders with deep insights into market volatility by measuring the directional strength of price movements. This sophisticated momentum-based tool helps identify overbought and oversold conditions, offering actionable buy and sell signals based on volatility trends and standard deviation bands.
🔶 CALCULATION
The indicator processes volatility quality data through a series of analytical steps:
Bar Range Calculation: Measures true range (TR) to capture price volatility.
Directional Weighting: Applies directional bias (positive for bullish candles, negative for bearish) to the true range.
VQI Computation: Uses an exponential moving average (EMA) of weighted volatility to derive the Volatility Quality Index (VQI).
vqiRaw = ta.ema(weightedVol, vqiLen)
Smoothing: Applies an additional EMA to smooth the VQI for clearer signals.
Normalization: Optionally normalizes VQI to a -100/+100 scale based on historical highs and lows.
Standard Deviation Bands: Calculates three upper and lower bands using standard deviation multipliers for volatility thresholds.
vqiStdev = ta.stdev(vqiSmoothed, vqiLen)
upperBand1 = vqiSmoothed + (vqiStdev * stdevMultiplier1)
upperBand2 = vqiSmoothed + (vqiStdev * stdevMultiplier2)
upperBand3 = vqiSmoothed + (vqiStdev * stdevMultiplier3)
lowerBand1 = vqiSmoothed - (vqiStdev * stdevMultiplier1)
lowerBand2 = vqiSmoothed - (vqiStdev * stdevMultiplier2)
lowerBand3 = vqiSmoothed - (vqiStdev * stdevMultiplier3)
Signal Generation: Produces overbought/oversold signals when VQI reaches extreme levels (±200 in normalized mode).
Formula:
Bar Range = True Range (TR)
Weighted Volatility = Bar Range × (Close > Open ? 1 : Close < Open ? -1 : 0)
VQI Raw = EMA(Weighted Volatility, VQI Length)
VQI Smoothed = EMA(VQI Raw, Smoothing Length)
VQI Normalized = ((VQI Smoothed - Lowest VQI) / (Highest VQI - Lowest VQI) - 0.5) × 200
Upper Band N = VQI Smoothed + (StdDev(VQI Smoothed, VQI Length) × Multiplier N)
Lower Band N = VQI Smoothed - (StdDev(VQI Smoothed, VQI Length) × Multiplier N)
🔶 DETAILS
Visual Features:
VQI Plot: Displays VQI as a line or histogram (lime for positive, red for negative).
Standard Deviation Bands: Plots three upper and lower bands (teal for upper, grayscale for lower) to indicate volatility thresholds.
Reference Levels: Horizontal lines at 0 (neutral), +100, and -100 (in normalized mode) for context.
Zone Highlighting: Overbought (⋎ above bars) and oversold (⋏ below bars) signals for extreme VQI levels (±200 in normalized mode).
Candle Coloring: Optional candle overlay colored by VQI direction (lime for positive, red for negative).
Interpretation:
VQI ≥ 200 (Normalized): Overbought condition, strong sell signal.
VQI 100–200: High volatility, potential selling opportunity.
VQI 0–100: Neutral bullish momentum.
VQI 0 to -100: Neutral bearish momentum.
VQI -100 to -200: High volatility, strong bearish momentum.
VQI ≤ -200 (Normalized): Oversold condition, strong buy signal.
🔶 EXAMPLES
Overbought Signal Detection: When VQI exceeds 200 (normalized), the indicator flags potential market tops with a red ⋎ symbol.
Example: During strong uptrends, VQI reaching 200 has historically preceded corrections, allowing traders to secure profits.
Oversold Signal Detection: When VQI falls below -200 (normalized), a lime ⋏ symbol highlights potential buying opportunities.
Example: In bearish markets, VQI dropping below -200 has marked reversal points for profitable long entries.
Volatility Trend Tracking: The VQI plot and bands help traders visualize shifts in market momentum.
Example: A rising VQI crossing above zero with widening bands indicates strengthening bullish momentum, guiding traders to hold or enter long positions.
Dynamic Support/Resistance: Standard deviation bands act as dynamic volatility thresholds during price movements.
Example: Price reversals often occur near the third standard deviation bands, providing reliable entry/exit points during volatile periods.
🔶 SETTINGS
Customization Options:
VQI Length: Adjust the EMA period for VQI calculation (default: 14, range: 1–50).
Smoothing Length: Set the EMA period for smoothing (default: 5, range: 1–50).
Standard Deviation Multipliers: Customize multipliers for bands (defaults: 1.0, 2.0, 3.0).
Normalization: Toggle normalization to -100/+100 scale and adjust lookback period (default: 200, min: 50).
Display Style: Switch between line or histogram plot for VQI.
Candle Overlay: Enable/disable VQI-colored candles (lime for positive, red for negative).
The Alpha-Extract Volatility Quality Indicator empowers traders with a robust tool to navigate market volatility. By combining directional price range analysis with smoothed volatility metrics, it identifies overbought and oversold conditions, offering clear buy and sell signals. The customizable standard deviation bands and optional normalization provide precise context for market conditions, enabling traders to make informed decisions across various market cycles.
MACD Breakout SuperCandlesMACD Breakout SuperCandles
The MACD Breakout SuperCandles indicator is a candle-coloring tool that monitors trend alignment across multiple timeframes using a combination of MACD behavior and simple price structure. It visually reflects market sentiment directly on price candles, helping traders quickly recognize shifting momentum conditions.
How It Works
The script evaluates trend behavior based on:
- Multi-timeframe MACD Analysis: Uses MACD values and signal line relationships to gauge trend direction and strength.
- Price Relative to SMA Zones: Analyzes whether price is positioned above or below the 20-period high and low SMAs on each timeframe.
For each timeframe, the script assigns one of five possible trend statuses:
- SUPERBULL: Strong bullish MACD signal with price above both SMAs.
- Bullish: Bullish MACD crossover with price showing upward bias.
- Basing: MACD flattening or neutralizing near zero with no directional dominance.
- Bearish: Bearish MACD signal without confirmation of stronger trend.
- SUPERBEAR: Strong bearish MACD signal with price below both SMAs.
-Ghost Candles: Candles with basing attributes that can signal directional change or trend strength.
Signal Scoring System
The script compares conditions across four timeframes:
- TF1 (Short)
- TF2 (Medium)
- TF3 (Long)
- MACD at a fixed 10-minute resolution
Each status type is tracked independently. A colored candle is only applied when a status type (e.g., SUPERBULL) reaches the minimum match threshold, defined by the "Min Status Matches for Candle Color" setting. If no status meets the required threshold, the candle is displayed in a neutral "Ghost" color.
Customizable Visuals
The indicator offers full control over candle appearance via grouped settings:
Body Colors
- SUPERBULL Body
- Bullish Body
- Basing Body
- Bearish Body
- SUPERBEAR Body
- Ghost Candle Body (used when no match)
Border & Wick Colors
- SUPERBULL Border/Wick
- Bullish Border/Wick
- Basing Border/Wick
- Bearish Border/Wick
- SUPERBEAR Border/Wick
- Ghost Border/Wick
Colors are grouped by function and can be adjusted independently to match your chart theme or personal preferences.
Settings Overview
- TF1, TF2, TF3: Select short, medium, and long timeframes to monitor trend structure.
- Min Status Matches: Set how many timeframes must agree before a candle status is applied.
- MACD Settings: Customize MACD fast, slow, and signal lengths, and choose MA type (EMA, SMA, WMA).
This tool helps visualize how aligned various timeframe conditions are by embedding sentiment into the candles themselves. It can assist with trend identification, momentum confirmation, or visual filtering for discretionary strategies.
light_logLight Log - A Defensive Programming Library for Pine Script
Overview
The Light Log library transforms Pine Script development by introducing structured logging and defensive programming patterns typically found in enterprise languages like C#. This library addresses a fundamental challenge in Pine Script: the lack of sophisticated error handling and debugging tools that developers expect when building complex trading systems.
At its core, Light Log provides three transformative capabilities that work together to create more reliable and maintainable code. First, it wraps all native Pine Script types in error-aware containers, allowing values to carry validation state alongside their data. Second, it offers a comprehensive logging system with severity levels and conditional rendering. Third, it includes defensive programming utilities that catch errors early and make code self-documenting.
The Philosophy of Errors as Values
Traditional Pine Script error handling relies on runtime errors that halt execution, making it difficult to build resilient systems that can gracefully handle edge cases. Light Log introduces a paradigm shift by treating errors as first-class values that flow through your program alongside regular data.
When you wrap a value using Light Log's type system, you're not just storing data – you're creating a container that can carry both the value and its validation state. For example, when you call myNumber.INT() , you receive an INT object that contains both the integer value and a Log object that can describe any issues with that value. This approach, inspired by functional programming languages, allows errors to propagate through calculations without causing immediate failures.
Consider how this changes error handling in practice. Instead of a calculation failing catastrophically when it encounters invalid input, it can produce a result object that contains both the computed value (which might be na) and a detailed log explaining what went wrong. Subsequent operations can check has_error() to decide whether to proceed or handle the error condition gracefully.
The Typed Wrapper System
Light Log provides typed wrappers for every native Pine Script type: INT, FLOAT, BOOL, STRING, COLOR, LINE, LABEL, BOX, TABLE, CHART_POINT, POLYLINE, and LINEFILL. These wrappers serve multiple purposes beyond simple value storage.
Each wrapper type contains two fields: the value field v holds the actual data, while the error field e contains a Log object that tracks the value's validation state. This dual nature enables powerful programming patterns. You can perform operations on wrapped values and accumulate error information along the way, creating an audit trail of how values were processed.
The wrapper system includes convenient methods for converting between wrapped and unwrapped values. The extension methods like INT() , FLOAT() , etc., make it easy to wrap existing values, while the from_INT() , from_FLOAT() methods extract the underlying values when needed. The has_error() method provides a consistent interface for checking whether any wrapped value has encountered issues during processing.
The Log Object: Your Debugging Companion
The Log object represents the heart of Light Log's debugging capabilities. Unlike simple string concatenation for error messages, the Log object provides a structured approach to building, modifying, and rendering diagnostic information.
Each Log object carries three essential pieces of information: an error type (info, warning, error, or runtime_error), a message string that can be built incrementally, and an active flag that controls conditional rendering. This structure enables sophisticated logging patterns where you can build up detailed diagnostic information throughout your script's execution and decide later whether and how to display it.
The Log object's methods support fluent chaining, allowing you to build complex messages in a readable way. The write() and write_line() methods append text to the log, while new_line() adds formatting. The clear() method resets the log for reuse, and the rendering methods ( render_now() , render_condition() , and the general render() ) control when and how messages appear.
Defensive Programming Made Easy
Light Log's argument validation functions transform how you write defensive code. Instead of cluttering your functions with verbose validation logic, you can use concise, self-documenting calls that make your intentions clear.
The argument_error() function provides strict validation that halts execution when conditions aren't met – perfect for catching programming errors early. For less critical issues, argument_log_warning() and argument_log_error() record problems without stopping execution, while argument_log_info() provides debug visibility into your function's behavior.
These functions follow a consistent pattern: they take a condition to check, the function name, the argument name, and a descriptive message. This consistency makes error messages predictable and helpful, automatically formatting them to show exactly where problems occurred.
Building Modular, Reusable Code
Light Log encourages a modular approach to Pine Script development by providing tools that make functions more self-contained and reliable. When functions validate their inputs and return wrapped values with error information, they become true black boxes that can be safely composed into larger systems.
The void_return() function addresses Pine Script's requirement that all code paths return a value, even in error handling branches. This utility function provides a clean way to satisfy the compiler while making it clear that a particular code path should never execute.
The static log pattern, initialized with init_static_log() , enables module-wide error tracking. You can create a persistent Log object that accumulates information across multiple function calls, building a comprehensive diagnostic report that helps you understand complex behaviors in your indicators and strategies.
Real-World Applications
In practice, Light Log shines when building sophisticated trading systems. Imagine developing a complex indicator that processes multiple data streams, performs statistical calculations, and generates trading signals. With Light Log, each processing stage can validate its inputs, perform calculations, and pass along both results and diagnostic information.
For example, a moving average calculation might check that the period is positive, that sufficient data exists, and that the input series contains valid values. Instead of failing silently or throwing runtime errors, it can return a FLOAT object that contains either the calculated average or a detailed explanation of why the calculation couldn't be performed.
Strategy developers benefit even more from Light Log's capabilities. Complex entry and exit logic often involves multiple conditions that must all be satisfied. With Light Log, each condition check can contribute to a comprehensive log that explains exactly why a trade was or wasn't taken, making strategy debugging and optimization much more straightforward.
Performance Considerations
While Light Log adds a layer of abstraction over raw Pine Script values, its design minimizes performance impact. The wrapper objects are lightweight, containing only two fields. The logging operations only consume resources when actually rendered, and the conditional rendering system ensures that production code can run with logging disabled for maximum performance.
The library follows Pine Script best practices for performance, using appropriate data structures and avoiding unnecessary operations. The var keyword in init_static_log() ensures that persistent logs don't create new objects on every bar, maintaining efficiency even in real-time calculations.
Getting Started
Adopting Light Log in your Pine Script projects is straightforward. Import the library, wrap your critical values, add validation to your functions, and use Log objects to track important events. Start small by adding logging to a single function, then expand as you see the benefits of better error visibility and code organization.
Remember that Light Log is designed to grow with your needs. You can use as much or as little of its functionality as makes sense for your project. Even simple uses, like adding argument validation to key functions, can significantly improve code reliability and debugging ease.
Transform your Pine Script development experience with Light Log – because professional trading systems deserve professional development tools.
Light Log Technical Deep Dive: Advanced Patterns and Architecture
Understanding Errors as Values
The concept of "errors as values" represents a fundamental shift in how we think about error handling in Pine Script. In traditional Pine Script development, errors are events – they happen at a specific moment in time and immediately interrupt program flow. Light Log transforms errors into data – they become information that flows through your program just like any other value.
This transformation has profound implications. When errors are values, they can be stored, passed between functions, accumulated, transformed, and inspected. They become part of your program's data flow rather than exceptions to it. This approach, popularized by languages like Rust with its Result type and Haskell with its Either monad, brings functional programming's elegance to Pine Script.
Consider a practical example. Traditional Pine Script might calculate a momentum indicator like this:
momentum = close - close
If period is invalid or if there isn't enough historical data, this calculation might produce na or cause subtle bugs. With Light Log's approach:
calculate_momentum(src, period)=>
result = src.FLOAT()
if period <= 0
result.e.write("Invalid period: must be positive", true, ErrorType.error)
result.v := na
else if bar_index < period
result.e.write("Insufficient data: need " + str.tostring(period) + " bars", true, ErrorType.warning)
result.v := na
else
result.v := src - src
result.e.write("Momentum calculated successfully", false, ErrorType.info)
result
Now the function returns not just a value but a complete computational result that includes diagnostic information. Calling code can make intelligent decisions based on both the value and its associated metadata.
The Monad Pattern in Pine Script
While Pine Script lacks the type system features to implement true monads, Light Log brings monadic thinking to Pine Script development. The wrapped types (INT, FLOAT, etc.) act as computational contexts that carry both values and metadata through a series of transformations.
The key insight of monadic programming is that you can chain operations while automatically propagating context. In Light Log, this context is the error state. When you have a FLOAT that contains an error, operations on that FLOAT can check the error state and decide whether to proceed or propagate the error.
This pattern enables what functional programmers call "railway-oriented programming" – your code follows a success track when all is well but can switch to an error track when problems occur. Both tracks lead to the same destination (a result with error information), but they take different paths based on the validity of intermediate values.
Composable Error Handling
Light Log's design encourages composition – building complex functionality from simpler, well-tested components. Each component can validate its inputs, perform its calculation, and return a result with appropriate error information. Higher-level functions can then combine these results intelligently.
Consider building a complex trading signal from multiple indicators:
generate_signal(src, fast_period, slow_period, signal_period) =>
log = init_static_log(ErrorType.info)
// Calculate components with error tracking
fast_ma = calculate_ma(src, fast_period)
slow_ma = calculate_ma(src, slow_period)
// Check for errors in components
if fast_ma.has_error()
log.write_line("Fast MA error: " + fast_ma.e.message, true)
if slow_ma.has_error()
log.write_line("Slow MA error: " + slow_ma.e.message, true)
// Proceed with calculation if no errors
signal = 0.0.FLOAT()
if not (fast_ma.has_error() or slow_ma.has_error())
macd_line = fast_ma.v - slow_ma.v
signal_line = calculate_ma(macd_line, signal_period)
if signal_line.has_error()
log.write_line("Signal line error: " + signal_line.e.message, true)
signal.e := log
else
signal.v := macd_line - signal_line.v
log.write("Signal generated successfully")
else
signal.e := log
signal.v := na
signal
This composable approach makes complex calculations more reliable and easier to debug. Each component is responsible for its own validation and error reporting, and the composite function orchestrates these components while maintaining comprehensive error tracking.
The Static Log Pattern
The init_static_log() function introduces a powerful pattern for maintaining state across function calls. In Pine Script, the var keyword creates variables that persist across bars but are initialized only once. Light Log leverages this to create logging objects that can accumulate information throughout a script's execution.
This pattern is particularly valuable for debugging complex strategies where you need to understand behavior across multiple bars. You can create module-level logs that track important events:
// Module-level diagnostic log
diagnostics = init_static_log(ErrorType.info)
// Track strategy decisions across bars
check_entry_conditions() =>
diagnostics.clear() // Start fresh each bar
diagnostics.write_line("Bar " + str.tostring(bar_index) + " analysis:")
if close > sma(close, 20)
diagnostics.write_line("Price above SMA20", false)
else
diagnostics.write_line("Price below SMA20 - no entry", true, ErrorType.warning)
if volume > sma(volume, 20) * 1.5
diagnostics.write_line("Volume surge detected", false)
else
diagnostics.write_line("Normal volume", false)
// Render diagnostics based on verbosity setting
if debug_mode
diagnostics.render_now()
Advanced Validation Patterns
Light Log's argument validation functions enable sophisticated precondition checking that goes beyond simple null checks. You can implement complex validation logic while keeping your code readable:
validate_price_data(open_val, high_val, low_val, close_val) =>
argument_error(na(open_val) or na(high_val) or na(low_val) or na(close_val),
"validate_price_data", "OHLC values", "contain na values")
argument_error(high_val < low_val,
"validate_price_data", "high/low", "high is less than low")
argument_error(close_val > high_val or close_val < low_val,
"validate_price_data", "close", "is outside high/low range")
argument_log_warning(high_val == low_val,
"validate_price_data", "high/low", "are equal (no range)")
This validation function documents its requirements clearly and fails fast with helpful error messages when assumptions are violated. The mix of errors (which halt execution) and warnings (which allow continuation) provides fine-grained control over how strict your validation should be.
Performance Optimization Strategies
While Light Log adds abstraction, careful design minimizes overhead. Understanding Pine Script's execution model helps you use Light Log efficiently.
Pine Script executes once per bar, so operations that seem expensive in traditional programming might have negligible impact. However, when building real-time systems, every optimization matters. Light Log provides several patterns for efficient use:
Lazy Evaluation: Log messages are only built when they'll be rendered. Use conditional logging to avoid string concatenation in production:
if debug_mode
log.write_line("Calculated value: " + str.tostring(complex_calculation))
Selective Wrapping: Not every value needs error tracking. Wrap values at API boundaries and critical calculation points, but use raw values for simple operations:
// Wrap at boundaries
input_price = close.FLOAT()
validated_period = validate_period(input_period).INT()
// Use raw values internally
sum = 0.0
for i = 0 to validated_period.v - 1
sum += close
Error Propagation: When errors occur early, avoid expensive calculations:
process_data(input) =>
validated = validate_input(input)
if validated.has_error()
validated // Return early with error
else
// Expensive processing only if valid
perform_complex_calculation(validated)
Integration Patterns
Light Log integrates smoothly with existing Pine Script code. You can adopt it incrementally, starting with critical functions and expanding coverage as needed.
Boundary Validation: Add Light Log at the boundaries of your system – where user input enters and where final outputs are produced. This catches most errors while minimizing changes to existing code.
Progressive Enhancement: Start by adding argument validation to existing functions. Then wrap return values. Finally, add comprehensive logging. Each step improves reliability without requiring a complete rewrite.
Testing and Debugging: Use Light Log's conditional rendering to create debug modes for your scripts. Production users see clean output while developers get detailed diagnostics:
// User input for debug mode
debug = input.bool(false, "Enable debug logging")
// Conditional diagnostic output
if debug
diagnostics.render_now()
else
diagnostics.render_condition() // Only shows errors/warnings
Future-Proofing Your Code
Light Log's patterns prepare your code for Pine Script's evolution. As Pine Script adds more sophisticated features, code that uses structured error handling and defensive programming will adapt more easily than code that relies on implicit assumptions.
The type wrapper system, in particular, positions your code to take advantage of potential future features or more sophisticated type inference. By thinking in terms of wrapped values and error propagation today, you're building code that will remain maintainable and extensible tomorrow.
Light Log doesn't just make your Pine Script better today – it prepares it for the trading systems you'll need to build tomorrow.
Library "light_log"
A lightweight logging and defensive programming library for Pine Script.
Designed for modular and extensible scripts, this utility provides structured runtime validation,
conditional logging, and reusable `Log` objects for centralized error propagation.
It also introduces a typed wrapping system for all native Pine values (e.g., `INT`, `FLOAT`, `LABEL`),
allowing values to carry errors alongside data. This enables functional-style flows with built-in
validation tracking, error detection (`has_error()`), and fluent chaining.
Inspired by structured logging patterns found in systems like C#, it reduces boilerplate,
enforces argument safety, and encourages clean, maintainable code architecture.
method INT(self, error_type)
Wraps an `int` value into an `INT` struct with an optional log severity.
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : The raw `int` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: An `INT` object containing the value and a default Log instance.
method FLOAT(self, error_type)
Wraps a `float` value into a `FLOAT` struct with an optional log severity.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : The raw `float` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `FLOAT` object containing the value and a default Log instance.
method BOOL(self, error_type)
Wraps a `bool` value into a `BOOL` struct with an optional log severity.
Namespace types: series bool, simple bool, input bool, const bool
Parameters:
self (bool) : The raw `bool` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOOL` object containing the value and a default Log instance.
method STRING(self, error_type)
Wraps a `string` value into a `STRING` struct with an optional log severity.
Namespace types: series string, simple string, input string, const string
Parameters:
self (string) : The raw `string` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `STRING` object containing the value and a default Log instance.
method COLOR(self, error_type)
Wraps a `color` value into a `COLOR` struct with an optional log severity.
Namespace types: series color, simple color, input color, const color
Parameters:
self (color) : The raw `color` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `COLOR` object containing the value and a default Log instance.
method LINE(self, error_type)
Wraps a `line` object into a `LINE` struct with an optional log severity.
Namespace types: series line
Parameters:
self (line) : The raw `line` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINE` object containing the value and a default Log instance.
method LABEL(self, error_type)
Wraps a `label` object into a `LABEL` struct with an optional log severity.
Namespace types: series label
Parameters:
self (label) : The raw `label` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LABEL` object containing the value and a default Log instance.
method BOX(self, error_type)
Wraps a `box` object into a `BOX` struct with an optional log severity.
Namespace types: series box
Parameters:
self (box) : The raw `box` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOX` object containing the value and a default Log instance.
method TABLE(self, error_type)
Wraps a `table` object into a `TABLE` struct with an optional log severity.
Namespace types: series table
Parameters:
self (table) : The raw `table` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `TABLE` object containing the value and a default Log instance.
method CHART_POINT(self, error_type)
Wraps a `chart.point` value into a `CHART_POINT` struct with an optional log severity.
Namespace types: chart.point
Parameters:
self (chart.point) : The raw `chart.point` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `CHART_POINT` object containing the value and a default Log instance.
method POLYLINE(self, error_type)
Wraps a `polyline` object into a `POLYLINE` struct with an optional log severity.
Namespace types: series polyline, series polyline, series polyline, series polyline
Parameters:
self (polyline) : The raw `polyline` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `POLYLINE` object containing the value and a default Log instance.
method LINEFILL(self, error_type)
Wraps a `linefill` object into a `LINEFILL` struct with an optional log severity.
Namespace types: series linefill
Parameters:
self (linefill) : The raw `linefill` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINEFILL` object containing the value and a default Log instance.
method from_INT(self)
Extracts the integer value from an INT wrapper.
Namespace types: INT
Parameters:
self (INT) : The wrapped INT instance.
Returns: The underlying `int` value.
method from_FLOAT(self)
Extracts the float value from a FLOAT wrapper.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The wrapped FLOAT instance.
Returns: The underlying `float` value.
method from_BOOL(self)
Extracts the boolean value from a BOOL wrapper.
Namespace types: BOOL
Parameters:
self (BOOL) : The wrapped BOOL instance.
Returns: The underlying `bool` value.
method from_STRING(self)
Extracts the string value from a STRING wrapper.
Namespace types: STRING
Parameters:
self (STRING) : The wrapped STRING instance.
Returns: The underlying `string` value.
method from_COLOR(self)
Extracts the color value from a COLOR wrapper.
Namespace types: COLOR
Parameters:
self (COLOR) : The wrapped COLOR instance.
Returns: The underlying `color` value.
method from_LINE(self)
Extracts the line object from a LINE wrapper.
Namespace types: LINE
Parameters:
self (LINE) : The wrapped LINE instance.
Returns: The underlying `line` object.
method from_LABEL(self)
Extracts the label object from a LABEL wrapper.
Namespace types: LABEL
Parameters:
self (LABEL) : The wrapped LABEL instance.
Returns: The underlying `label` object.
method from_BOX(self)
Extracts the box object from a BOX wrapper.
Namespace types: BOX
Parameters:
self (BOX) : The wrapped BOX instance.
Returns: The underlying `box` object.
method from_TABLE(self)
Extracts the table object from a TABLE wrapper.
Namespace types: TABLE
Parameters:
self (TABLE) : The wrapped TABLE instance.
Returns: The underlying `table` object.
method from_CHART_POINT(self)
Extracts the chart.point from a CHART_POINT wrapper.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The wrapped CHART_POINT instance.
Returns: The underlying `chart.point` value.
method from_POLYLINE(self)
Extracts the polyline object from a POLYLINE wrapper.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The wrapped POLYLINE instance.
Returns: The underlying `polyline` object.
method from_LINEFILL(self)
Extracts the linefill object from a LINEFILL wrapper.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The wrapped LINEFILL instance.
Returns: The underlying `linefill` object.
method has_error(self)
Returns true if the INT wrapper has an active log entry.
Namespace types: INT
Parameters:
self (INT) : The INT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the FLOAT wrapper has an active log entry.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The FLOAT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOOL wrapper has an active log entry.
Namespace types: BOOL
Parameters:
self (BOOL) : The BOOL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the STRING wrapper has an active log entry.
Namespace types: STRING
Parameters:
self (STRING) : The STRING instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the COLOR wrapper has an active log entry.
Namespace types: COLOR
Parameters:
self (COLOR) : The COLOR instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINE wrapper has an active log entry.
Namespace types: LINE
Parameters:
self (LINE) : The LINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LABEL wrapper has an active log entry.
Namespace types: LABEL
Parameters:
self (LABEL) : The LABEL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOX wrapper has an active log entry.
Namespace types: BOX
Parameters:
self (BOX) : The BOX instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the TABLE wrapper has an active log entry.
Namespace types: TABLE
Parameters:
self (TABLE) : The TABLE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the CHART_POINT wrapper has an active log entry.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The CHART_POINT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the POLYLINE wrapper has an active log entry.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The POLYLINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINEFILL wrapper has an active log entry.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The LINEFILL instance to check.
Returns: True if an error or message is active in the log.
void_return()
Utility function used when a return is syntactically required but functionally unnecessary.
Returns: Nothing. Function never executes its body.
argument_error(condition, function, argument, message)
Throws a runtime error when a condition is met. Used for strict argument validation.
Parameters:
condition (bool) : Boolean expression that triggers the runtime error.
function (string) : Name of the calling function (for formatting).
argument (string) : Name of the problematic argument.
message (string) : Description of the error cause.
Returns: Never returns. Halts execution if the condition is true.
argument_log_info(condition, function, argument, message)
Logs an informational message when a condition is met. Used for optional debug visibility.
Parameters:
condition (bool) : Boolean expression that triggers the log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Informational message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_warning(condition, function, argument, message)
Logs a warning when a condition is met. Non-fatal but highlights potential issues.
Parameters:
condition (bool) : Boolean expression that triggers the warning.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Warning message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_error(condition, function, argument, message)
Logs an error message when a condition is met. Does not halt execution.
Parameters:
condition (bool) : Boolean expression that triggers the error log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Error message to log.
Returns: Nothing. Logs if the condition is true.
init_static_log(error_type, message, active)
Initializes a persistent (var) Log object. Ideal for global logging in scripts or modules.
Parameters:
error_type (series ErrorType) : Initial severity level (required).
message (string) : Optional starting message string. Default value of ("").
active (bool) : Whether the log should be flagged active on initialization. Default value of (false).
Returns: A static Log object with the given parameters.
method new_line(self)
Appends a newline character to the Log message. Useful for separating entries during chained writes.
Namespace types: Log
Parameters:
self (Log) : The Log instance to modify.
Returns: The updated Log object with a newline appended.
method write(self, message, flag_active, error_type)
Appends a message to a Log object without a newline. Updates severity and active state if specified.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method write_line(self, message, flag_active, error_type)
Appends a message to a Log object, prefixed with a newline for clarity.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method clear(self, flag_active, error_type)
Clears a Log object’s message and optionally reactivates it. Can also update the error type.
Namespace types: Log
Parameters:
self (Log) : The Log instance being cleared.
flag_active (bool) : Whether to activate the log after clearing. Default value of (false).
error_type (series ErrorType) : Optional new error type to assign. If not provided, the previous type is retained. Default value of (na).
Returns: The cleared Log object.
method render_condition(self, flag_active, error_type)
Conditionally renders the log if it is active. Allows overriding error type and controlling active state afterward.
Namespace types: Log
Parameters:
self (Log) : The Log instance to evaluate and render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Useful for contextual formatting just before rendering. Default value of (na).
Returns: The updated Log object.
method render_now(self, flag_active, error_type)
Immediately renders the log regardless of `active` state. Allows overriding error type and active flag.
Namespace types: Log
Parameters:
self (Log) : The Log instance to render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Allows dynamic severity adjustment at render time. Default value of (na).
Returns: The updated Log object.
render(self, condition, flag_active, error_type)
Renders the log conditionally or unconditionally. Allows full control over render behavior.
Parameters:
self (Log) : The Log instance to render.
condition (bool) : If true, renders only if the log is active. If false, always renders. Default value of (false).
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override passed to the render methods. Default value of (na).
Returns: The updated Log object.
Log
A structured object used to store and render logging messages.
Fields:
error_type (series ErrorType) : The severity level of the message (from the ErrorType enum).
message (series string) : The text of the log message.
active (series bool) : Whether the log should trigger rendering when conditionally evaluated.
INT
A wrapped integer type with attached logging for validation or tracing.
Fields:
v (series int) : The underlying `int` value.
e (Log) : Optional log object describing validation status or error context.
FLOAT
A wrapped float type with attached logging for validation or tracing.
Fields:
v (series float) : The underlying `float` value.
e (Log) : Optional log object describing validation status or error context.
BOOL
A wrapped boolean type with attached logging for validation or tracing.
Fields:
v (series bool) : The underlying `bool` value.
e (Log) : Optional log object describing validation status or error context.
STRING
A wrapped string type with attached logging for validation or tracing.
Fields:
v (series string) : The underlying `string` value.
e (Log) : Optional log object describing validation status or error context.
COLOR
A wrapped color type with attached logging for validation or tracing.
Fields:
v (series color) : The underlying `color` value.
e (Log) : Optional log object describing validation status or error context.
LINE
A wrapped line object with attached logging for validation or tracing.
Fields:
v (series line) : The underlying `line` value.
e (Log) : Optional log object describing validation status or error context.
LABEL
A wrapped label object with attached logging for validation or tracing.
Fields:
v (series label) : The underlying `label` value.
e (Log) : Optional log object describing validation status or error context.
BOX
A wrapped box object with attached logging for validation or tracing.
Fields:
v (series box) : The underlying `box` value.
e (Log) : Optional log object describing validation status or error context.
TABLE
A wrapped table object with attached logging for validation or tracing.
Fields:
v (series table) : The underlying `table` value.
e (Log) : Optional log object describing validation status or error context.
CHART_POINT
A wrapped chart point with attached logging for validation or tracing.
Fields:
v (chart.point) : The underlying `chart.point` value.
e (Log) : Optional log object describing validation status or error context.
POLYLINE
A wrapped polyline object with attached logging for validation or tracing.
Fields:
v (series polyline) : The underlying `polyline` value.
e (Log) : Optional log object describing validation status or error context.
LINEFILL
A wrapped linefill object with attached logging for validation or tracing.
Fields:
v (series linefill) : The underlying `linefill` value.
e (Log) : Optional log object describing validation status or error context.
