Templates

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}

================================================================================
HOW TO CREATE AN INDICATOR - A BEGINNER'S GUIDE
================================================================================

This template shows you how to create indicators for Quant Charts.
It's designed to be super easy - if you know basic Python, you're ready!

STEP 1: Import what you need
STEP 2: Add the @indicator decorator
STEP 3: Define parameters as class attributes
STEP 4: Write your calculation in calculate(self, df)
STEP 5: Plot the result

Let's go through each step below...

NOTE ON OPTIMIZATION SWEEPS:
Indicators used inside a strategy are also called once per param per day during
a sweep. When an indicator does param-independent work (e.g. a rolling window on
`close` with a literal period, heavy mask building), hoist it the same way the
strategy template does: put param-independent setup in a `prep(self, df)` method
(it runs once per day and is passed to `calculate` as `prep`), and keep only the
`self.*`-dependent work in `calculate`.
"""

# =============================================================================
# STEP 1: IMPORT WHAT YOU NEED
# =============================================================================
# These are the building blocks for your indicator.
#
# - indicator: The decorator that makes your class into an indicator
# - input: Create adjustable parameters (period, color, etc.)
# - plot: Draw lines on the chart
# - close: Access closing prices (this is a pandas Series!)
# - hline: Draw horizontal reference lines (optional)
# - fill: Fill area between two lines (optional)

from quant_charts import indicator, input, plot, close


# =============================================================================
# STEP 2: ADD THE @indicator DECORATOR
# =============================================================================
# The decorator tells Quant Charts this is an indicator.
#
# Parameters:
#   - First arg: The name shown in the UI (e.g., "SMA", "RSI")
#   - overlay=True: Draw ON the price chart (like moving averages)
#   - overlay=False: Draw in a SEPARATE pane (like RSI, MACD)
#
# Example for an oscillator that needs its own pane:
#   @indicator("RSI", overlay=False)

@indicator("{NAME}", overlay=True)  # Python indicators run on OHLC bars; for TBBO tick indicators use a Rust .rs file
class {CLASS_NAME}:
    # =========================================================================
    # STEP 3: DEFINE PARAMETERS
    # =========================================================================
    # Each parameter becomes a slider/input in the settings panel.
    # Users can adjust these without editing your code!
    #
    # Format: name = input.type(default, "Label", options...)
    #
    # Available types:
    #   input.int()    - Whole numbers (periods, lookbacks)
    #   input.float()  - Decimals (multipliers, thresholds)
    #   input.bool()   - True/False toggle
    #   input.color()  - Color picker
    #   input.string() - Text or dropdown menu

    period = input.int(20, "Period", min=1, max=500)
    color = input.color("#2962FF", "Line Color")

    def calculate(self, df):
        """
        {NAME} Indicator

        This is your indicator's description.
        Write a brief explanation of what it does.
        """

        # =====================================================================
        # STEP 4: WRITE YOUR CALCULATION
        # =====================================================================
        # The 'close' variable is a pandas Series containing all closing prices.
        # Use 'self.period' and 'self.color' to access your parameters.
        #
        # You can use ANY pandas operations on it:
        #
        #   close.rolling(20).mean()     - Simple moving average
        #   close.ewm(span=20).mean()    - Exponential moving average
        #   close.diff()                  - Price change from previous bar
        #   close.pct_change()            - Percentage change
        #   close.rolling(20).std()       - Standard deviation (volatility)
        #   close.shift(1)                - Previous bar's value
        #   close > close.shift(1)        - True if price went up
        #
        # Example: Simple Moving Average
        result = close.rolling(self.period).mean()

        # =====================================================================
        # STEP 5: PLOT THE RESULT
        # =====================================================================
        # Use plot() to draw your indicator on the chart.
        #
        # Parameters:
        #   - series: Your calculated data (pandas Series)
        #   - name: Label shown in the legend
        #   - color: Hex color (e.g., "#2962FF" is blue)
        #   - linewidth: Line thickness (1-5, default is 2)

        plot(result, f"{NAME}({self.period})", color=self.color, linewidth=2)


# =============================================================================
# THAT'S IT! Your indicator is ready.
# =============================================================================
# Save this file and it will automatically appear in your indicator list.
# The period and color can be adjusted in the settings panel.


# =============================================================================
# BONUS: MORE EXAMPLES
# =============================================================================
#
# --- Example: RSI with tags (overbought/oversold) ---
# from quant_charts import indicator, input, plot, hline, close, define_tag
#
# @indicator("RSI", overlay=False)
# class RSI:
#     period = input.int(14, "Period", min=2, max=100)
#     overbought = input.int(70, "Overbought", min=50, max=100)
#     oversold = input.int(30, "Oversold", min=0, max=50)
#
#     def calculate(self, df):
#         delta = close.diff()
#         gain = delta.where(delta > 0, 0).rolling(self.period).mean()
#         loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()
#         rs = gain / loss
#         rsi_value = 100 - (100 / (1 + rs))
#
#         plot(rsi_value, "RSI", color="#9C27B0")
#         hline(self.overbought, "Overbought", color="#EF5350", linestyle="dashed")
#         hline(self.oversold, "Oversold", color="#26A69A", linestyle="dashed")
#
#         define_tag("overbought", f"RSI > {self.overbought}", color="#DC2626")
#         define_tag("oversold", f"RSI < {self.oversold}", color="#16A34A")
#
#         return {
#             "overbought": rsi_value > self.overbought,
#             "oversold": rsi_value < self.oversold,
#         }
#
#
# --- Example: Bollinger Bands with fill ---
# from quant_charts import indicator, input, plot, fill, close
#
# @indicator("Bollinger Bands", overlay=True)
# class BollingerBands:
#     period = input.int(20, "Period")
#     std_dev = input.float(2.0, "Std Dev", min=0.5, max=5.0)
#     color = input.color("#2962FF", "Color")
#
#     def calculate(self, df):
#         middle = close.rolling(self.period).mean()
#         std = close.rolling(self.period).std()
#         upper = middle + (std * self.std_dev)
#         lower = middle - (std * self.std_dev)
#
#         plot(middle, "Middle", color=self.color)
#         plot(upper, "Upper", color=self.color, linewidth=1)
#         plot(lower, "Lower", color=self.color, linewidth=1)
#         fill("Upper", "Lower", color=self.color, opacity=10)
#
#
# --- Example: Two-line crossover (Fast/Slow MA) ---
# from quant_charts import indicator, input, plot, close
#
# @indicator("MA Crossover", overlay=True)
# class MACrossover:
#     fast = input.int(10, "Fast Period", min=1, max=100)
#     slow = input.int(20, "Slow Period", min=1, max=200)
#
#     def calculate(self, df):
#         fast_ma = close.rolling(self.fast).mean()
#         slow_ma = close.rolling(self.slow).mean()
#
#         plot(fast_ma, f"Fast({self.fast})", color="#26A69A")
#         plot(slow_ma, f"Slow({self.slow})", color="#EF5350")


# =============================================================================
# QUICK REFERENCE CHEAT SHEET
# =============================================================================
#
# PRICE DATA (all are pandas Series):
#   close      - Closing prices
#   open       - Opening prices
#   high       - Highest prices
#   low        - Lowest prices
#   volume     - Trading volume
#   hl2        - (High + Low) / 2
#   hlc3       - (High + Low + Close) / 3
#   ohlc4      - (Open + High + Low + Close) / 4
#
# INPUT TYPES:
#   input.int(default, "Label", min=X, max=Y, step=Z)
#   input.float(default, "Label", min=X, max=Y, step=Z)
#   input.bool(default, "Label")
#   input.color("#RRGGBB", "Label")
#   input.string("default", "Label", options=["A", "B", "C"])
#   input.source(Source.CLOSE, "Label")
#   input.timeframe("tick", "Label")
#
# PLOTTING:
#   plot(series, "Name", color="#HEX", linewidth=2)
#   hline(value, "Name", color="#HEX", linestyle="dashed")
#   fill("Series1 Name", "Series2 Name", color="#HEX", opacity=20)
#
# COMMON COLORS:
#   #2962FF - Blue (default)
#   #26A69A - Green (bullish)
#   #EF5350 - Red (bearish)
#   #FF9800 - Orange
#   #9C27B0 - Purple
#   #787B86 - Gray
#
# PANDAS OPERATIONS (use on close, open, high, low, volume):
#   .rolling(N).mean()  - Simple moving average over N bars
#   .ewm(span=N).mean() - Exponential moving average
#   .rolling(N).std()   - Standard deviation
#   .rolling(N).max()   - Highest value in N bars
#   .rolling(N).min()   - Lowest value in N bars
#   .diff()             - Change from previous bar
#   .pct_change()       - Percentage change
#   .shift(1)           - Previous bar's value
#   .abs()              - Absolute value

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}
"""

from quant_charts import script, input


@script(
    name="{NAME}",
    description="Enter description here",
)
class {CLASS_NAME}:
    """
    Your generic script class

    Use scripts for data processing, analysis, exports, or any custom logic
    that doesn't fit the indicator or strategy paradigm.
    """

    # Define your parameters here
    output_file = input.string(
        default="output.csv",
        label="Output File",
        tooltip="Name of the output file"
    )

    threshold = input.float(
        default=1.0,
        label="Threshold",
        min=0.0,
        max=100.0,
        tooltip="Threshold value for processing"
    )

    def run(self, df):
        """
        Main entry point for the script

        Args:
            df: pandas DataFrame with OHLCV data (if available)

        Returns:
            Any value or None
        """
        # Your script logic here
        print(f"Running {self.__class__.__name__}")
        print(f"Output file: {self.output_file}")
        print(f"Threshold: {self.threshold}")

        # Example: Process data
        if df is not None:
            print(f"DataFrame shape: {df.shape}")
            # Do something with df...

        return None

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}
"""

import numpy as np
import quant_charts as qc


# The model in one sentence: your signals describe the position you WANT, and
# the engine holds one position at a time and executes it faithfully. There are
# no execution "modes":
#   - entry_long while flat            -> open long
#   - entry_short while long           -> REVERSE (close long + open short)
#   - exit_long while long             -> close to flat
#   - entry_long again while long      -> stay long (a level, no churn)
# Return `size` (scalar or per-bar array) to set contracts per position; omit it
# for unit size. See the EMA Flip / Trail SL/TP / VP Limit built-ins for more.
@qc.strategy(name="{NAME}", timeframe="1m")
class {CLASS_NAME}:
    fast_period = qc.input.int(10, "Fast Period", min=2, max=100)
    slow_period = qc.input.int(20, "Slow Period", min=2, max=200)

    # Optional: hoist param-independent work into prep(). It runs once per day
    # and its return dict is passed to calculate() as `prep`. Delete it (and the
    # `prep` arg below) if calculate() is cheap enough to run per combination.
    def prep(self, df):
        return {"close": np.asarray(df["close"], dtype=np.float64)}

    def calculate(self, df, prep):
        close = prep["close"]
        fast = qc.ta.sma(close, self.fast_period)
        slow = qc.ta.sma(close, self.slow_period)

        return {
            "entry_long":  qc.cross_above(fast, slow),
            "exit_long":   qc.cross_below(fast, slow),
            "entry_short": qc.cross_below(fast, slow),
            "exit_short":  qc.cross_above(fast, slow),
            # "size": 1,   # contracts per position (scalar broadcasts; array sizes per entry)
        }

//! qc-api: 1.0.8
// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

use qc_strategy_api::prelude::*;

/// [YOUR STRATEGY NAME]
///
/// Rust TBBO strategies run per-tick across every parameter combination in parallel.
/// You have full access to bid/ask/mid/spread/bid_size/ask_size on every tick, plus
/// any extra columns the parquet emitted via `data.col("name")`. Missing columns return
/// `None` so your strategy stays robust even on files that lack optional fields.
///
/// - `columns = [...]` (optional): a hint for the UI + loader. Undeclared columns still
///   work via `data.col("name")`; declaring them just surfaces the list in the inspector.
/// - `#[tag(...)]`  (optional): per-tag label/color metadata. Undeclared tag names still
///   emit; they just get auto-generated labels.
#[strategy(
    name = "My Strategy",
    description = "Strategy description",
    columns = ["volume", "delta"],
)]
#[tag(name = "trend_up", label = "Trend Up Entry", color = "#26A69A")]
#[tag(name = "trend_dn", label = "Trend Down Entry", color = "#EF5350")]
#[derive(Default)]
pub struct MyStrategy {
    // Declare each parameter with its range and default. The optimizer sweeps these
    // across the combinations you configure in the UI. Only fields annotated with
    // `#[param(...)]` are filled from the UI; any other field on this struct is
    // initialized via Default::default() so you can keep per-combo caches or state.
    #[param(default = 20, min = 5, max = 100, label = "Period")]
    pub period: usize,

    #[param(default = 2.0, min = 0.5, max = 5.0, step = 0.25, label = "Multiplier")]
    pub multiplier: f64,

    // Custom state (non-param): seed it in Default or compute it lazily in calculate().
    // It is re-built per combo, so treat it as scratch memory.
    #[allow(dead_code)]
    pub scratch: Vec<f64>,
}

impl Strategy for MyStrategy {
    // Optional per-day precomputation. Runs ONCE per day, before the combo sweep.
    // Cache heavy parameter-independent work here (ATR, bucket aggregations, etc.).
    fn prepare(data: &TickData) -> DayPrep {
        let mut prep = DayPrep::empty();
        let atr = ta::atr_bid_ask(&data.bid, &data.ask, 30);
        prep.insert_f64("atr", atr);
        prep
    }

    fn calculate(&self, data: &TickData, prep: &DayPrep) -> SignalOutput {
        let n = data.len();

        // Column access is free-form: any string the parquet has works.
        //   let vol   = data.col_or("volume", &[]);
        //   let delta = data.col_or("delta", &[]);
        //   let custom = data.col("my_custom_col");  // Option<&[f64]>
        // qc_log! writes to the Rust worker's stderr, which surfaces in the VSC output:
        //   qc_log!("loaded {} ticks, has_volume={}", n, data.has_volume());

        let (upper, middle, lower) = ta::bollinger(&data.mid, self.period, self.multiplier);
        let atr = prep.f64("atr").unwrap_or(&[]);

        let mut entry_long = vec![false; n];
        let mut exit_long = vec![false; n];
        let mut entry_short = vec![false; n];
        let mut exit_short = vec![false; n];
        let mut sl_long = vec![f64::NAN; n];
        let mut sl_short = vec![f64::NAN; n];
        // Tag arrays: same length as ticks, true when the condition holds.
        let mut trend_up = vec![false; n];
        let mut trend_dn = vec![false; n];

        for i in self.period..n {
            if data.mid[i] < lower[i] {
                entry_long[i] = true;
                if let Some(a) = atr.get(i) {
                    sl_long[i] = data.mid[i] - a * 2.0;
                }
                trend_up[i] = true;
            }
            if data.mid[i] > upper[i] {
                entry_short[i] = true;
                if let Some(a) = atr.get(i) {
                    sl_short[i] = data.mid[i] + a * 2.0;
                }
                trend_dn[i] = true;
            }
            if middle[i].is_finite() {
                exit_long[i] = data.mid[i] >= middle[i];
                exit_short[i] = data.mid[i] <= middle[i];
            }
        }

        SignalOutput::new(entry_long, exit_long, entry_short, exit_short)
            .with_sl_long(sl_long)
            .with_sl_short(sl_short)
            .with_entry_only_sltp()
            // Free-form tags: any name works. Declare them via #[tag(...)] above
            // for UI label/color, or leave them undeclared and the system will auto-assign.
            .with_tag("trend_up", trend_up)
            .with_tag("trend_dn", trend_dn)
    }
}

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Order-flow: per-bar delta histogram + cumulative volume delta.

`delta_series` resolves the per-bar signed volume via the fallback chain
`delta -> ask_vol - bid_vol -> sign(close - open)`. `cvd()` accumulates it.
"""

import numpy as np
import quant_charts as qc


@qc.indicator("Order Flow", overlay=False)
class OrderFlow:
    tags = {
        "delta_positive":     qc.Tag("Per-bar buy-side delta",   "#26A69A"),
        "delta_negative":     qc.Tag("Per-bar sell-side delta",  "#EF5350"),
        "heavy_buy_pressure": qc.Tag("Heavy bid imbalance",      "#26A69A"),
        "heavy_sell_pressure":qc.Tag("Heavy ask imbalance",      "#EF5350"),
    }

    imbalance_threshold = qc.input.float(0.65, "Imbalance Threshold", min=0.5, max=1.0, step=0.01)
    pos_color = qc.input.color("#26A69A", "Buy Pressure Color")
    neg_color = qc.input.color("#EF5350", "Sell Pressure Color")

    def calculate(self, df):
        n = len(df)

        delta_arr = qc.delta_series(df)
        cvd_arr   = qc.cvd(delta_arr)

        delta_colors = np.where(delta_arr >= 0, self.pos_color, self.neg_color)
        qc.plot_histogram_colored(delta_arr, "Delta", color=self.pos_color, colors=delta_colors)
        qc.hline(0.0, "Zero", color="#63636e", linestyle="dashed")
        qc.plot(cvd_arr, "CVD", color="#7AA2F7", linewidth=2)

        bid_vol_arr = qc.df_col_or(df, "bid_vol")
        ask_vol_arr = qc.df_col_or(df, "ask_vol")
        if bid_vol_arr is not None and ask_vol_arr is not None:
            imb = qc.imbalance(bid_vol_arr, ask_vol_arr)
            heavy_buy  = imb > self.imbalance_threshold
            heavy_sell = imb < (1.0 - self.imbalance_threshold)
        else:
            heavy_buy  = np.zeros(n, dtype=bool)
            heavy_sell = np.zeros(n, dtype=bool)

        return {
            "delta_positive":      delta_arr > 0,
            "delta_negative":      delta_arr < 0,
            "heavy_buy_pressure":  heavy_buy,
            "heavy_sell_pressure": heavy_sell,
        }

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""RSI oscillator in its own pane, with overbought / oversold / neutral tags.

The smallest demo of a non-overlay indicator: `overlay=False` puts it in a
separate pane, `qc.ta.rsi` does the Wilder smoothing, and `qc.hline` draws the
reference levels. The three tag arrays let the analyzer split stats by regime
(and a strategy can gate entries on them via `qc.use_indicator`).
"""

import numpy as np
import quant_charts as qc


@qc.indicator("RSI", overlay=False)
class Rsi:
    tags = {
        "overbought": qc.Tag("RSI above the overbought level", "#EF5350"),
        "oversold":   qc.Tag("RSI below the oversold level",   "#26A69A"),
        "neutral":    qc.Tag("RSI between the two levels",      "#A1A1AA"),
    }

    period     = qc.input.int(14, "RSI Period", min=2, max=10000)
    overbought = qc.input.int(70, "Overbought", min=50, max=100)
    oversold   = qc.input.int(30, "Oversold",   min=0,  max=50)
    line_color = qc.input.color("#BB9AF7", "RSI Color")

    def calculate(self, df):
        rsi = qc.ta.rsi(df.close, self.period)

        qc.plot(rsi, f"RSI({self.period})", color=self.line_color, linewidth=2)
        qc.hline(float(self.overbought), "Overbought", color="#EF5350", linestyle="dashed")
        qc.hline(float(self.oversold),   "Oversold",   color="#26A69A", linestyle="dashed")
        qc.hline(50.0,                   "Midline",    color="#63636e", linestyle="dotted")

        finite = np.isfinite(rsi)
        overbought = (rsi > self.overbought) & finite
        oversold   = (rsi < self.oversold) & finite
        neutral    = finite & ~overbought & ~oversold
        return {
            "overbought": overbought,
            "oversold":   oversold,
            "neutral":    neutral,
        }

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Swing Labels - draw your own marks on the chart with the custom canvas API.

`plot` / `hline` / `plotshape` cover the common cases. When you want something
they cannot express (a zig-zag, a filled marker, a price text label), reach for
`custom_layer`: an imperative 2D canvas you draw on directly, replayed through
the chart's renderer with pan / zoom respected.

This indicator finds fractal swing highs / lows and, for each, draws:
- a zig-zag polyline connecting the pivots in order,
- a small filled triangle pointing at the bar,
- a price text label.

The canvas builder chains: `.style(...)` sets a sticky style, `.begin()` opens a
path, `.move_to()` / `.line_to()` trace it, `.close()` / `.fill()` / `.stroke()`
render it, and `.text()` draws a label. `.emit()` registers the layer (you do not
need to return it). `z="top"` keeps the marks above the candles.

Pivots are confirmed using bars on BOTH sides, so a fresh pivot only appears once
the chart has printed `strength` more bars past it.
"""

import numpy as np
import pandas as pd
import quant_charts as qc


@qc.indicator("Swing Labels", overlay=True)
class SwingLabels:
    tags = {
        "swing_high": qc.Tag("Bar is a confirmed fractal swing high", "#F7768E"),
        "swing_low":  qc.Tag("Bar is a confirmed fractal swing low",  "#73DACA"),
    }

    strength   = qc.input.int(3, "Pivot Strength", min=1, max=100,
                              tooltip="Bars required on each side of a pivot to confirm it.")
    high_color = qc.input.color("#F7768E", "Swing High Color")
    low_color  = qc.input.color("#73DACA", "Swing Low Color")
    show_labels = qc.input.bool(True, "Price Labels")

    def calculate(self, df):
        high = np.asarray(df["high"], dtype=np.float64)
        low = np.asarray(df["low"], dtype=np.float64)
        ts = np.asarray(df["timestamp"], dtype=np.float64)
        n = len(high)
        if n == 0:
            return {"swing_high": np.zeros(0, bool), "swing_low": np.zeros(0, bool)}

        # Fractal pivots: the window is centered, so it reads `strength` bars on
        # either side. NaN edges compare False, so the first/last bars never mark.
        win = 2 * self.strength + 1
        is_high = (pd.Series(high) == pd.Series(high).rolling(win, center=True).max()).to_numpy()
        is_low = (pd.Series(low) == pd.Series(low).rolling(win, center=True).min()).to_numpy()

        # Vertical breathing room for marks / labels, scaled to recent range so
        # they sit just off the bar at any price.
        atr = qc.ta.atr(df["high"], df["low"], df["close"], 14)
        off = np.nanmedian(atr)
        if not np.isfinite(off) or off <= 0:
            off = float(np.nanmedian(high - low)) or 1.0
        diffs = np.diff(ts)
        bar_ms = float(np.median(diffs[diffs > 0])) if np.any(diffs > 0) else 60_000.0
        half = bar_ms * 0.4

        hi_idx = np.flatnonzero(is_high)
        lo_idx = np.flatnonzero(is_low)

        layer = qc.custom_layer("swing-labels", z="top")

        # Zig-zag: one stroked path through every pivot in chronological order.
        pivots = sorted(
            [(ts[i], high[i]) for i in hi_idx] + [(ts[i], low[i]) for i in lo_idx],
            key=lambda p: p[0],
        )
        if len(pivots) >= 2:
            layer.style(stroke="#565f8988", line_width=1.0, dash=[2, 3])
            layer.begin()
            layer.move_to(pivots[0])
            for pt in pivots[1:]:
                layer.line_to(pt)
            layer.stroke()

        # Swing highs: down-triangle above the bar, label on top.
        layer.style(fill=self.high_color, stroke=self.high_color, line_width=1.0,
                    dash=[], font="11px Inter", text_align="center", text_baseline="bottom")
        for i in hi_idx:
            top = high[i] + off * 0.7
            layer.begin()
            layer.move_to((ts[i] - half, top))
            layer.line_to((ts[i] + half, top))
            layer.line_to((ts[i], high[i] + off * 0.15))
            layer.close().fill().stroke()
            if self.show_labels:
                layer.text((ts[i], top + off * 0.1), f"{high[i]:.2f}")

        # Swing lows: up-triangle below the bar, label underneath.
        layer.style(fill=self.low_color, stroke=self.low_color, text_baseline="top")
        for i in lo_idx:
            bot = low[i] - off * 0.7
            layer.begin()
            layer.move_to((ts[i] - half, bot))
            layer.line_to((ts[i] + half, bot))
            layer.line_to((ts[i], low[i] - off * 0.15))
            layer.close().fill().stroke()
            if self.show_labels:
                layer.text((ts[i], bot - off * 0.1), f"{low[i]:.2f}")

        layer.emit()
        return {"swing_high": is_high, "swing_low": is_low}

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Volume Profile - anchored profile with POC, value area, and HVN/LVN tags.

For true per-print fidelity (every tick binned, not just bar typical price),
use the Rust `volume_profile.rs` indicator. This Python version is bar-level: fast and
portable, but coarser on heavy-trading bars.
"""

import numpy as np
import quant_charts as qc


@qc.indicator("Volume Profile")
class VolumeProfile:
    tags = {
        "at_poc":            qc.Tag("Close near POC",              "#E0AF68"),
        "inside_value_area": qc.Tag("Close between VAL and VAH",   "#73DACA"),
        "above_vah":         qc.Tag("Close above VAH",             "#26A69A"),
        "below_val":         qc.Tag("Close below VAL",             "#EF5350"),
        "near_hvn":          qc.Tag("Close near a high-volume node", "#7AA2F7"),
        "near_lvn":          qc.Tag("Close near a low-volume node",  "#F7768E"),
    }

    anchor_kind     = qc.input.string("aligned_hour", "Anchor",
                                      options=["session", "aligned_hour", "aligned_30m", "aligned_15m"])
    use_completed_vp = qc.input.bool(True, "Use Completed VP")
    row_size        = qc.input.float(0.25, "Row Size", min=0.01, max=100.0, step=0.01)
    value_area_pct  = qc.input.float(0.70, "Value Area %", min=0.10, max=0.99, step=0.01)
    hvn_threshold   = qc.input.float(0.85, "HVN Threshold", min=0.30, max=1.00, step=0.05)
    lvn_threshold   = qc.input.float(0.20, "LVN Threshold", min=0.01, max=0.50, step=0.01)
    proximity_ticks = qc.input.int(2, "Proximity (ticks)", min=0, max=100)
    poc_color       = qc.input.color("#E0AF68", "POC Color")
    va_color        = qc.input.color("#73DACA", "Value Area Color")
    render_histogram   = qc.input.bool(True, "Render Histogram")
    histogram_color    = qc.input.color("#7AA2F7", "Histogram Color")
    histogram_align    = qc.input.string("right_of_range", "Histogram Align",
                                         options=["right_of_range", "left_of_range", "over_range", "pinned_right", "pinned_left"])
    histogram_width_px = qc.input.int(80, "Histogram Width (px)", min=20, max=400, step=5)

    _ANCHOR_MS = {"aligned_hour": 3_600_000, "aligned_30m": 1_800_000, "aligned_15m": 900_000}

    def _build_period_vp(self, high, low, close, vol):
        finite = (np.isfinite(high) & np.isfinite(low) & np.isfinite(close)
                  & np.isfinite(vol) & (vol > 0.0))
        if not finite.any():
            return None
        h, l, v = high[finite], low[finite], vol[finite]
        lo, hi = float(np.min(l)), float(np.max(h))
        if not (np.isfinite(lo) and np.isfinite(hi)) or hi <= lo:
            return None

        bin_count = max(1, int(np.ceil((hi - lo) / self.row_size)) + 1)
        b_lo = np.clip(((l - lo) / self.row_size).astype(np.int64), 0, bin_count - 1)
        b_hi = np.clip(((h - lo) / self.row_size).astype(np.int64), 0, bin_count - 1)
        share = v / (b_hi - b_lo + 1).astype(np.float64)
        diff = np.zeros(bin_count + 1, dtype=np.float64)
        np.add.at(diff, b_lo, share)
        np.add.at(diff, b_hi + 1, -share)
        rows = np.cumsum(diff[:-1])
        total = float(rows.sum())
        if total <= 0.0:
            return None

        poc_bin = int(np.argmax(rows))
        poc_price = lo + (poc_bin + 0.5) * self.row_size
        poc_vol = float(rows[poc_bin])

        target = total * self.value_area_pct
        cum = poc_vol
        lo_b = hi_b = poc_bin
        while cum < target and (lo_b > 0 or hi_b < bin_count - 1):
            left  = rows[lo_b - 1] if lo_b > 0 else -1.0
            right = rows[hi_b + 1] if hi_b < bin_count - 1 else -1.0
            if right >= left:
                hi_b += 1; cum += rows[hi_b]
            else:
                lo_b -= 1; cum += rows[lo_b]
        val_p = lo + (lo_b + 0.5) * self.row_size
        vah_p = lo + (hi_b + 0.5) * self.row_size

        hvn_levels, lvn_levels = [], []
        for i in range(1, bin_count - 1):
            if i == poc_bin:
                continue
            r = rows[i]
            if r >= self.hvn_threshold * poc_vol and r >= rows[i - 1] and r >= rows[i + 1]:
                hvn_levels.append(lo + (i + 0.5) * self.row_size)
            elif r <= self.lvn_threshold * poc_vol and r <= rows[i - 1] and r <= rows[i + 1] and r > 0:
                lvn_levels.append(lo + (i + 0.5) * self.row_size)

        return {"poc_price": poc_price, "vah": vah_p, "val": val_p,
                "hvn_levels": hvn_levels, "lvn_levels": lvn_levels,
                "bins": rows, "price_min": lo, "total_volume": total}

    def calculate(self, df):
        high  = np.asarray(df["high"],  dtype=np.float64)
        low   = np.asarray(df["low"],   dtype=np.float64)
        close = np.asarray(df["close"], dtype=np.float64)
        vol   = qc.volume_series(df)
        n = len(close)
        if n == 0:
            return {}

        ts = np.asarray(df["timestamp"], dtype=np.int64) if "timestamp" in df.columns else None

        if self.anchor_kind == "session" or ts is None:
            anchor_idx = np.zeros(n, dtype=np.int64)
            bucket_starts = np.array([int(ts[0]) if ts is not None and ts.size > 0 else 0], dtype=np.int64)
        else:
            period_ms = self._ANCHOR_MS.get(self.anchor_kind, 3_600_000)
            bucket = (ts // period_ms) * period_ms
            bucket_starts, anchor_idx = np.unique(bucket, return_inverse=True)

        num_periods = int(bucket_starts.size)
        period_vps = [None] * num_periods
        period_anchor_ts = [int(bucket_starts[p]) for p in range(num_periods)]
        period_last_ts = [0] * num_periods
        for p in range(num_periods):
            mask = anchor_idx == p
            if not mask.any():
                continue
            res = self._build_period_vp(high[mask], low[mask], close[mask], vol[mask])
            if res is None:
                continue
            period_vps[p] = res
            if ts is not None:
                p_ts = ts[mask]
                if p_ts.size > 0:
                    period_last_ts[p] = int(p_ts[-1])

        prox = self.proximity_ticks * self.row_size
        at_poc    = np.zeros(n, dtype=bool)
        inside_va = np.zeros(n, dtype=bool)
        above_vah = np.zeros(n, dtype=bool)
        below_val = np.zeros(n, dtype=bool)
        near_hvn_arr = np.zeros(n, dtype=bool)
        near_lvn_arr = np.zeros(n, dtype=bool)

        ref_for_period = [None] * num_periods
        for p in range(num_periods):
            base = p - 1 if self.use_completed_vp else p
            while base >= 0 and period_vps[base] is None:
                base -= 1
            ref_for_period[p] = period_vps[base] if base >= 0 else None

        for i in range(n):
            ref = ref_for_period[int(anchor_idx[i])]
            if ref is None:
                continue
            c = close[i]
            if abs(c - ref["poc_price"]) <= prox: at_poc[i] = True
            if c >= ref["val"] and c <= ref["vah"]: inside_va[i] = True
            if c > ref["vah"]: above_vah[i] = True
            if c < ref["val"]: below_val[i] = True
            for lvl in ref["hvn_levels"]:
                if abs(c - lvl) <= prox: near_hvn_arr[i] = True; break
            for lvl in ref["lvn_levels"]:
                if abs(c - lvl) <= prox: near_lvn_arr[i] = True; break

        last_completed = num_periods - 1
        if self.use_completed_vp:
            last_completed -= 1
        while last_completed >= 0 and period_vps[last_completed] is None:
            last_completed -= 1
        if last_completed >= 0:
            r = period_vps[last_completed]
            qc.hline(r["poc_price"], "POC", color=self.poc_color, linestyle="solid")
            qc.hline(r["vah"], "VAH", color=self.va_color, linestyle="dashed")
            qc.hline(r["val"], "VAL", color=self.va_color, linestyle="dashed")

        if self.render_histogram and ts is not None:
            max_visual = num_periods - 1 if self.use_completed_vp else num_periods
            for p in range(max_visual):
                v = period_vps[p]
                if v is None:
                    continue
                anchor_ts = period_anchor_ts[p]
                end_ts = period_anchor_ts[p + 1] if p + 1 < num_periods else period_last_ts[p]
                if self.use_completed_vp:
                    line_anchor = end_ts
                    line_end = period_anchor_ts[p + 2] if p + 2 < num_periods else int(ts[-1])
                    if line_end < line_anchor: line_end = line_anchor
                else:
                    line_anchor = anchor_ts
                    line_end = end_ts
                qc.vp_visual(
                    anchor_ts=int(anchor_ts), end_ts=int(end_ts),
                    price_min=float(v["price_min"]), price_step=float(self.row_size),
                    bins=v["bins"],
                    poc_price=float(v["poc_price"]), vah=float(v["vah"]), val=float(v["val"]),
                    color=self.histogram_color, poc_color=self.poc_color,
                    value_area_color=self.va_color, opacity=60,
                    width_px=int(self.histogram_width_px), align=self.histogram_align,
                    style="bars",
                    hvn_levels=v["hvn_levels"] if v["hvn_levels"] else None,
                    lvn_levels=v["lvn_levels"] if v["lvn_levels"] else None,
                    draw_level_lines=True,
                    level_lines_anchor_ts=int(line_anchor),
                    level_lines_end_ts=int(line_end),
                )

        return {
            "at_poc": at_poc, "inside_value_area": inside_va,
            "above_vah": above_vah, "below_val": below_val,
            "near_hvn": near_hvn_arr, "near_lvn": near_lvn_arr,
        }

# qc-api: 1.0.8
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Session VWAP with deviation bands and above/inside/below tags.

`qc.vwap_series` handles the column-priority fallback: precomputed `vwap` column
when present, else session-cumulative VWAP from typical price * volume.
"""

import numpy as np
import quant_charts as qc


@qc.indicator("VWAP", continuous=True)
class Vwap:
    tags = {
        "above_vwap_band":  qc.Tag("Close above VWAP + N sigma", "#26A69A"),
        "below_vwap_band":  qc.Tag("Close below VWAP - N sigma", "#EF5350"),
        "inside_vwap_band": qc.Tag("Close within +/- N sigma of VWAP", "#A1A1AA"),
    }

    band_mult  = qc.input.float(2.0, "Band Multiplier (x sigma)", min=0.0, max=10.0, step=0.05)
    line_color = qc.input.color("#7AA2F7", "VWAP Color")
    band_color = qc.input.color("#73DACA", "Band Color")

    def calculate(self, df):
        vwap     = qc.vwap_series(df)
        vol_safe = qc.volume_series(df)
        close_arr = np.asarray(df.close, dtype=np.float64)

        diff = close_arr - vwap
        cum_var_num = np.cumsum((diff * diff) * vol_safe)
        cum_vol     = np.cumsum(vol_safe)
        var   = cum_var_num / np.where(cum_vol > 0.0, cum_vol, np.nan)
        sigma = np.sqrt(np.maximum(var, 0.0))

        upper = vwap + self.band_mult * sigma
        lower = vwap - self.band_mult * sigma

        qc.plot(vwap,  "VWAP",        color=self.line_color, linewidth=2)
        qc.plot(upper, "VWAP Upper",  color=self.band_color, linewidth=1, opacity=60)
        qc.plot(lower, "VWAP Lower",  color=self.band_color, linewidth=1, opacity=60)
        qc.fill("VWAP Upper", "VWAP Lower", color=self.band_color, opacity=8)

        finite = np.isfinite(upper) & np.isfinite(lower)
        above_band  = (close_arr > upper) & finite
        below_band  = (close_arr < lower) & finite
        inside_band = finite & ~above_band & ~below_band
        return {
            "above_vwap_band":  above_band,
            "below_vwap_band":  below_band,
            "inside_vwap_band": inside_band,
        }

//! qc-api: 1.0.8
// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

//! ATR (Rust / OHLC bars).
//!
//! Required columns: high, low, close. Data mode: OHLC bars.
//!
//! Wilder ATR over `period` bars. The chart timeframe pill picks the bar
//! cadence (1m, 5m, ...). Three regime tags fire based on ATR vs the day's
//! median bar-ATR. Renders only in OHLC chart views.

use qc_strategy_api::prelude::*;

#[indicator(
    name = "ATR",
    description = "Wilder ATR with low/medium/high regime tags. OHLC-mode.",
    overlay = false,
    data_mode = "ohlc",
    timeframe = "1m"
)]
#[tag(name = "low_atr",    label = "Low ATR",    color = "#7AA2F7", description = "Bar ATR below low_mult x median")]
#[tag(name = "medium_atr", label = "Medium ATR", color = "#A1A1AA", description = "Bar ATR between low_mult and high_mult x median")]
#[tag(name = "high_atr",   label = "High ATR",   color = "#F7768E", description = "Bar ATR above high_mult x median")]
#[derive(Default)]
pub struct Atr {
    #[param(default = 14, min = 2, max = 500, label = "ATR Period (bars)",
            tooltip = "ATR lookback in bars at the indicator's declared timeframe.")]
    pub period: usize,

    #[param(default = 0.7, min = 0.0, max = 10.0, step = 0.05, label = "Low Threshold (x median)",
            tooltip = "Bar ATR below this many medians = low_atr.")]
    pub low_mult: f64,

    #[param(default = 1.4, min = 0.0, max = 10.0, step = 0.05, label = "High Threshold (x median)",
            tooltip = "Bar ATR above this many medians = high_atr.")]
    pub high_mult: f64,
}

impl OhlcIndicator for Atr {
    fn calculate(&self, data: &BarData, _prep: &DayPrep) -> IndicatorOutput {
        let n = data.len();
        if n == 0 || self.period < 2 {
            return IndicatorOutput::new().with_overlay(false);
        }

        // Wilder ATR over bar high/low/close.
        let mut atr = vec![f64::NAN; n];
        if n > self.period {
            let mut tr = vec![0.0; n];
            tr[0] = (data.high[0] - data.low[0]).max(0.0);
            for i in 1..n {
                let h = data.high[i];
                let l = data.low[i];
                let pc = data.close[i - 1];
                tr[i] = (h - l).max((h - pc).abs()).max((l - pc).abs());
            }
            let p = self.period as f64;
            let seed: f64 = tr[..self.period].iter().sum::<f64>() / p;
            atr[self.period - 1] = seed;
            for i in self.period..n {
                atr[i] = (atr[i - 1] * (p - 1.0) + tr[i]) / p;
            }
        }

        // Regime thresholds from the day's median bar ATR.
        let mut finite: Vec<f64> = atr.iter().copied().filter(|v| v.is_finite()).collect();
        let median_atr = if finite.is_empty() {
            f64::NAN
        } else {
            finite.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
            finite[finite.len() / 2]
        };
        let low_thresh = median_atr * self.low_mult;
        let high_thresh = median_atr * self.high_mult;

        let mut low_atr = vec![false; n];
        let mut medium_atr = vec![false; n];
        let mut high_atr = vec![false; n];
        for i in 0..n {
            let v = atr[i];
            if !v.is_finite() {
                continue;
            }
            if v < low_thresh {
                low_atr[i] = true;
            } else if v > high_thresh {
                high_atr[i] = true;
            } else {
                medium_atr[i] = true;
            }
        }

        IndicatorOutput::new()
            .with_overlay(false)
            .plot_line("ATR", atr, "#E0AF68")
            .with_tag("low_atr", low_atr)
            .with_tag("medium_atr", medium_atr)
            .with_tag("high_atr", high_atr)
    }
}

//! qc-api: 1.0.8
// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

//! Moving Averages (Rust / OHLC bars).
//!
//! Required columns: close. Data mode: OHLC bars.
//!
//! Fast / slow / trend EMAs drawn ON the price chart (`overlay = true`), the
//! canonical price-pane `OhlcIndicator`. Three stack-order tags fire from the
//! relative position of the three lines: a clean bullish stack (fast > slow >
//! trend), a clean bearish stack (fast < slow < trend), or anything in between.
//! Clone this file and swap `ta::ema` for `ta::sma` (or mix the two) to build
//! your own overlay.

use qc_strategy_api::prelude::*;

#[indicator(
    name = "Moving Averages",
    description = "Fast / slow / trend EMA overlay with bullish / bearish / mixed stack tags. OHLC-mode.",
    overlay = true,
    data_mode = "ohlc",
    timeframe = "1m"
)]
#[tag(name = "bull_stack",  label = "Bullish Stack",  color = "#26A69A", description = "fast EMA > slow EMA > trend EMA")]
#[tag(name = "bear_stack",  label = "Bearish Stack",  color = "#EF5350", description = "fast EMA < slow EMA < trend EMA")]
#[tag(name = "mixed_stack", label = "Mixed",          color = "#A1A1AA", description = "EMAs not cleanly stacked either way")]
#[derive(Default)]
pub struct MovingAverages {
    #[param(default = 9, min = 2, max = 5000, label = "Fast EMA (bars)",
            tooltip = "Fast EMA lookback in bars at the indicator's declared timeframe.")]
    pub fast: usize,

    #[param(default = 21, min = 2, max = 5000, label = "Slow EMA (bars)",
            tooltip = "Slow EMA lookback in bars.")]
    pub slow: usize,

    #[param(default = 50, min = 2, max = 5000, label = "Trend EMA (bars)",
            tooltip = "Trend EMA lookback in bars. The slowest of the three; defines the stack baseline.")]
    pub trend: usize,
}

impl OhlcIndicator for MovingAverages {
    fn calculate(&self, data: &BarData, _prep: &DayPrep) -> IndicatorOutput {
        let n = data.len();
        if n == 0 {
            return IndicatorOutput::new().with_overlay(true);
        }

        let fast = ta::ema(&data.close, self.fast);
        let slow = ta::ema(&data.close, self.slow);
        let trend = ta::ema(&data.close, self.trend);

        let mut bull = vec![false; n];
        let mut bear = vec![false; n];
        let mut mixed = vec![false; n];
        for i in 0..n {
            let (f, s, t) = (fast[i], slow[i], trend[i]);
            if !(f.is_finite() && s.is_finite() && t.is_finite()) {
                continue;
            }
            if f > s && s > t {
                bull[i] = true;
            } else if f < s && s < t {
                bear[i] = true;
            } else {
                mixed[i] = true;
            }
        }

        IndicatorOutput::new()
            .with_overlay(true)
            .plot_line("Fast EMA", fast, "#7AA2F7")
            .plot_line("Slow EMA", slow, "#E0AF68")
            .plot_line("Trend EMA", trend, "#BB9AF7")
            .with_tag("bull_stack", bull)
            .with_tag("bear_stack", bear)
            .with_tag("mixed_stack", mixed)
    }
}