back-trader-python 1.4.0__py3-none-any.whl

backtrader/indicators/contrib/atr_normalize_histogram.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "AtrNormalizeHistogram",
+]
+
+
+class AtrNormalizeHistogram(Indicator):
+    """ATR-normalized histogram indicator for multi-timeframe signal generation.
+
+    Computes a normalized ATR value where xdiff is smoothed range ratio,
+    colored by threshold crossings (high/middle/low levels).
+    """
+
+    lines = ("value", "color")
+    params = (
+        ("ma_method1", "SMA"),
+        ("length1", 14),
+        ("phase1", 15),
+        ("ma_method2", "SMA"),
+        ("length2", 14),
+        ("phase2", 15),
+        ("high_level", 60),
+        ("middle_level", 50),
+        ("low_level", 40),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialise indicator state: rolling buffers and prior smoothing values."""
+        self._diff_buf = []
+        self._range_buf = []
+        self._diff_prev = None
+        self._range_prev = None
+        self.addminperiod(max(int(self.p.length1), int(self.p.length2)) + 5)
+
+    def _smooth(self, raw_value, method, length, phase, buf, prev_attr):
+        """Apply SMA, LWMA, or exponential smoothing to a raw value.
+
+        Args:
+            raw_value: The raw input value.
+            method: Smoothing method ('SMA', 'LWMA', or EMA variant).
+            length: Lookback window length.
+            phase: Phase parameter for EMA variants (-100 to 100).
+            buf: Rolling buffer list.
+            prev_attr: Attribute name to store previous smoothed value.
+
+        Returns:
+            Smoothed value as float.
+        """
+        method = str(method).upper()
+        length = max(1, int(length))
+        if method in ("MODE_SMA_", "SMA"):
+            if len(buf) < length:
+                return raw_value
+            return sum(buf[-length:]) / float(length)
+        if method in ("MODE_LWMA_", "LWMA"):
+            if len(buf) < length:
+                return raw_value
+            weights = list(range(1, length + 1))
+            values = buf[-length:]
+            return sum(v * w for v, w in zip(values, weights)) / float(sum(weights))
+
+        prev = getattr(self, prev_attr)
+        phase = max(-100, min(100, int(phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if prev is None or not math.isfinite(prev):
+            smooth = raw_value
+        else:
+            smooth = prev + alpha * (raw_value - prev)
+        setattr(self, prev_attr, smooth)
+        return smooth
+
+    def next(self):
+        """Compute per-bar normalized ATR value and color classification."""
+        prev_close = float(self.data.close[-1]) if len(self.data) > 1 else float(self.data.close[0])
+        diff = float(self.data.close[0]) - float(self.data.low[0])
+        range_value = max(float(self.data.high[0]), prev_close) - min(
+            float(self.data.low[0]), prev_close
+        )
+        self._diff_buf.append(diff)
+        self._range_buf.append(range_value)
+        xdiff = self._smooth(
+            diff, self.p.ma_method1, self.p.length1, self.p.phase1, self._diff_buf, "_diff_prev"
+        )
+        xrange = self._smooth(
+            range_value,
+            self.p.ma_method2,
+            self.p.length2,
+            self.p.phase2,
+            self._range_buf,
+            "_range_prev",
+        )
+        xrange = max(xrange, float(self.p.point))
+        value = 100.0 * xdiff / xrange
+        if value > float(self.p.high_level):
+            color = 0.0
+        elif value > float(self.p.middle_level):
+            color = 1.0
+        elif value < float(self.p.low_level):
+            color = 4.0
+        elif value < float(self.p.middle_level):
+            color = 3.0
+        else:
+            color = 2.0
+        self.lines.value[0] = value
+        self.lines.color[0] = color

backtrader/indicators/contrib/average_change_candle.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "AverageChangeCandle",
+]
+
+
+class AverageChangeCandle(Indicator):
+    """Custom Average Change Candle indicator that computes power-scaled smoothed lines.
+
+    Lines:
+        open_line (LineSeries): Smoothed open line.
+        high_line (LineSeries): Smoothed high line.
+        low_line (LineSeries): Smoothed low line.
+        close_line (LineSeries): Smoothed close line.
+        color (LineSeries): Candle color state (0 = bearish, 1 = flat, 2 = bullish).
+    """
+
+    lines = (
+        "open_line",
+        "high_line",
+        "low_line",
+        "close_line",
+        "color",
+    )
+
+    params = (
+        ("ma_method1", "LWMA"),
+        ("length1", 12),
+        ("phase1", 15),
+        ("ipc1", "PRICE_MEDIAN_"),
+        ("ma_method2", "JJMA"),
+        ("length2", 5),
+        ("phase2", 100),
+        ("pow_value", 5.0),
+    )
+
+    def __init__(self):
+        """Initialize indicator variables, buffer lists, and min periods."""
+        self.addminperiod(max(int(self.p.length1), int(self.p.length2)) + 10)
+        self._base_buf = []
+        self._o_buf = []
+        self._h_buf = []
+        self._l_buf = []
+        self._c_buf = []
+        self._base_prev = None
+        self._o_prev = None
+        self._h_prev = None
+        self._l_prev = None
+        self._c_prev = None
+
+    def _price_series(self):
+        mode = str(self.p.ipc1).upper()
+        o = float(self.data.open[0])
+        h = float(self.data.high[0])
+        low_price = float(self.data.low[0])
+        c = float(self.data.close[0])
+        if mode == "PRICE_OPEN_":
+            return o
+        if mode == "PRICE_HIGH_":
+            return h
+        if mode == "PRICE_LOW_":
+            return low_price
+        if mode == "PRICE_TYPICAL_":
+            return (h + low_price + c) / 3.0
+        if mode == "PRICE_WEIGHTED_":
+            return (h + low_price + c + c) / 4.0
+        if mode == "PRICE_SIMPL_":
+            return (o + c) / 2.0
+        if mode == "PRICE_QUARTER_":
+            return (h + low_price + o + c) / 4.0
+        if mode == "PRICE_DEMARK_":
+            return (h + low_price + 2.0 * c) / 4.0
+        return (h + low_price) / 2.0
+
+    def _smooth(self, raw_value, method, length, phase, buf, prev_value_attr):
+        method = str(method).upper()
+        length = max(1, int(length))
+        if method in ("MODE_SMA_", "SMA"):
+            if len(buf) < length:
+                return raw_value
+            return sum(buf[-length:]) / float(length)
+        if method in ("MODE_LWMA_", "LWMA"):
+            if len(buf) < length:
+                return raw_value
+            weights = list(range(1, length + 1))
+            values = buf[-length:]
+            denom = float(sum(weights))
+            return sum(v * w for v, w in zip(values, weights)) / denom
+        prev = getattr(self, prev_value_attr)
+        phase = max(-100, min(100, int(phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if prev is None or not math.isfinite(prev):
+            smooth = raw_value
+        else:
+            smooth = prev + alpha * (raw_value - prev)
+        setattr(self, prev_value_attr, smooth)
+        return smooth
+
+    def next(self):
+        """Compute smoothed and power-scaled candle lines on each bar."""
+        base_price = self._price_series()
+        self._base_buf.append(base_price)
+        xma = self._smooth(
+            base_price,
+            self.p.ma_method1,
+            self.p.length1,
+            self.p.phase1,
+            self._base_buf,
+            "_base_prev",
+        )
+        xma = xma if xma != 0 else 1e-12
+
+        power = float(self.p.pow_value)
+        o_raw = math.pow(float(self.data.open[0]) / xma, power)
+        h_raw = math.pow(float(self.data.high[0]) / xma, power)
+        l_raw = math.pow(float(self.data.low[0]) / xma, power)
+        c_raw = math.pow(float(self.data.close[0]) / xma, power)
+
+        self._o_buf.append(o_raw)
+        self._h_buf.append(h_raw)
+        self._l_buf.append(l_raw)
+        self._c_buf.append(c_raw)
+
+        o_val = self._smooth(
+            o_raw, self.p.ma_method2, self.p.length2, self.p.phase2, self._o_buf, "_o_prev"
+        )
+        h_val = self._smooth(
+            h_raw, self.p.ma_method2, self.p.length2, self.p.phase2, self._h_buf, "_h_prev"
+        )
+        l_val = self._smooth(
+            l_raw, self.p.ma_method2, self.p.length2, self.p.phase2, self._l_buf, "_l_prev"
+        )
+        c_val = self._smooth(
+            c_raw, self.p.ma_method2, self.p.length2, self.p.phase2, self._c_buf, "_c_prev"
+        )
+
+        max_body = max(o_val, c_val)
+        min_body = min(o_val, c_val)
+        h_val = max(max_body, h_val)
+        l_val = min(min_body, l_val)
+
+        if o_val < c_val:
+            color = 2.0
+        elif o_val > c_val:
+            color = 0.0
+        else:
+            color = 1.0
+
+        self.lines.open_line[0] = o_val
+        self.lines.high_line[0] = h_val
+        self.lines.low_line[0] = l_val
+        self.lines.close_line[0] = c_val
+        self.lines.color[0] = color

backtrader/indicators/contrib/bb_squeeze_indicator.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ATR,
+    SMA,
+    BollingerBands,
+    Indicator,
+    Momentum,
+)
+
+__all__ = [
+    "BBSqueezeIndicator",
+]
+
+
+class BBSqueezeIndicator(Indicator):
+    """
+    Bollinger Band Squeeze: measures BB width relative to Keltner Channel.
+    Histogram = close - midline of (BB + KC) / 2, colored by whether
+    BB is inside KC (squeeze on) or outside (squeeze off).
+    Simplified: histogram = momentum (close - SMA), signal direction by
+    BB bandwidth vs KC bandwidth.
+    """
+
+    lines = (
+        "squeeze",
+        "momentum",
+    )
+    params = (
+        ("bb_period", 20),
+        ("bb_dev", 2.0),
+        ("kc_period", 20),
+        ("kc_mult", 1.5),
+        ("mom_period", 12),
+    )
+
+    def __init__(self):
+        """Instantiate BB, ATR, SMA, and momentum indicators used by the squeeze."""
+        self.bb = BollingerBands(self.data.close, period=self.p.bb_period, devfactor=self.p.bb_dev)
+        self.atr = ATR(self.data, period=self.p.kc_period)
+        self.sma = SMA(self.data.close, period=self.p.kc_period)
+        self.mom = Momentum(self.data.close, period=self.p.mom_period)
+
+    def next(self):
+        """Calculate squeeze state and momentum for every new bar."""
+        bb_upper = float(self.bb.top[0])
+        bb_lower = float(self.bb.bot[0])
+        bb_width = bb_upper - bb_lower
+
+        kc_upper = float(self.sma[0]) + self.p.kc_mult * float(self.atr[0])
+        kc_lower = float(self.sma[0]) - self.p.kc_mult * float(self.atr[0])
+        kc_width = kc_upper - kc_lower
+
+        self.lines.squeeze[0] = 1.0 if bb_width < kc_width else -1.0
+        self.lines.momentum[0] = float(self.mom[0])

backtrader/indicators/contrib/bezier_st_dev_indicator.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "BezierStDevIndicator",
+]
+
+
+def _factorial(n):
+    r = 1
+    for i in range(2, n + 1):
+        r *= i
+    return r
+
+
+def _price_series(ipc, data, ago=0):
+    """Replicate MQ5 PriceSeries with Applied_price_ enum."""
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if ipc == 0:
+        return c  # PRICE_CLOSE_
+    if ipc == 1:
+        return o  # PRICE_OPEN_
+    if ipc == 2:
+        return h  # PRICE_HIGH_
+    if ipc == 3:
+        return low_price  # PRICE_LOW_
+    if ipc == 4:
+        return (h + low_price) / 2.0  # PRICE_MEDIAN_
+    if ipc == 5:
+        return (h + low_price + c) / 3.0  # PRICE_TYPICAL_
+    if ipc == 6:
+        return (h + low_price + c + c) / 4.0  # PRICE_WEIGHTED_
+    return c
+
+
+class BezierStDevIndicator(Indicator):
+    """Reconstructs Bezier_StDev indicator.
+
+    Bezier curve interpolation of price over BPeriod, then StDev filter
+    on the first derivative to generate Bulls/Bears signals.
+    Buffers: 0=BezierLine, 1=ColorIndex, 2=BearsBuffer(sell), 3=BullsBuffer(buy).
+    """
+
+    lines = ("bezier", "color", "bears", "bulls")
+    params = (
+        ("bperiod", 8),
+        ("t_param", 0.5),
+        ("ipc", 6),
+        ("dk", 2.0),
+        ("std_period", 9),
+    )
+
+    def __init__(self):
+        """Cache parameters and precompute coefficients for Bezier interpolation."""
+        self._bp = int(self.p.bperiod)
+        self._t = float(self.p.t_param)
+        self._ipc = int(self.p.ipc)
+        self._dk = float(self.p.dk)
+        self._sp = int(self.p.std_period)
+        # Precompute binomial coefficients
+        n = self._bp
+        self._binom = [_factorial(n) / (_factorial(i) * _factorial(n - i)) for i in range(n + 1)]
+        self.addminperiod(self._bp + self._sp + 3)
+
+    def next(self):
+        """Compute Bezier line, color, and bullish/bearish derivative filters."""
+        bp = self._bp
+        t = self._t
+        ipc = self._ipc
+        dk = self._dk
+        sp = self._sp
+
+        # Compute Bezier for current and previous sp+1 bars
+        bezier_vals = []
+        needed = sp + 2
+        for k in range(needed):
+            r = 0.0
+            for i in range(bp + 1):
+                ago = k + i
+                if ago >= len(self.data):
+                    break
+                price = _price_series(ipc, self.data, ago)
+                r += price * self._binom[i] * (t**i) * ((1 - t) ** (bp - i))
+            bezier_vals.append(r)
+
+        bz_cur = bezier_vals[0]
+        self.lines.bezier[0] = bz_cur
+
+        # Color
+        if len(bezier_vals) > 1:
+            bz_prev = bezier_vals[1]
+            if bz_cur > bz_prev:
+                self.lines.color[0] = 1.0
+            elif bz_cur < bz_prev:
+                self.lines.color[0] = 2.0
+            else:
+                self.lines.color[0] = 0.0
+        else:
+            self.lines.color[0] = 0.0
+
+        # StDev filter on derivatives
+        d_bezier = []
+        for i in range(sp):
+            if i + 1 < len(bezier_vals):
+                d_bezier.append(bezier_vals[i] - bezier_vals[i + 1])
+            else:
+                d_bezier.append(0.0)
+
+        mean_d = sum(d_bezier) / sp if sp > 0 else 0
+        var_sum = sum((d - mean_d) ** 2 for d in d_bezier)
+        std_dev = math.sqrt(var_sum / sp) if sp > 0 else 0
+
+        dstd = d_bezier[0] if d_bezier else 0
+        filt = dk * std_dev
+
+        bulls = 0.0
+        bears = 0.0
+        if dstd > filt:
+            bulls = bz_cur
+        if dstd < -filt:
+            bears = bz_cur
+
+        self.lines.bulls[0] = bulls
+        self.lines.bears[0] = bears