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

backtrader/indicators/contrib/mt5_stochastic_close_close.py

@@ -0,0 +1,57 @@
+#!/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 Indicator
+
+__all__ = [
+    "Mt5StochasticCloseClose",
+]
+
+
+class Mt5StochasticCloseClose(Indicator):
+    """Close-close based Smoothed Stochastic oscillator implementation."""
+
+    lines = ("main", "signal")
+    params = (
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+    )
+
+    def __init__(self):
+        """Set calculation parameters and initial EMA-smoothed state."""
+        self.addminperiod(self.p.k_period + max(self.p.d_period, self.p.slowing) + 2)
+        self._slow_prev = None
+        self._signal_prev = None
+        self._alpha_slow = 2.0 / (self.p.slowing + 1.0)
+        self._alpha_signal = 2.0 / (self.p.d_period + 1.0)
+
+    def next(self):
+        """Compute smoothed %K/%D and emit current oscillator lines."""
+        closes = [float(self.data.close[-i]) for i in range(self.p.k_period)]
+        highest_close = max(closes)
+        lowest_close = min(closes)
+        close0 = float(self.data.close[0])
+        if highest_close == lowest_close:
+            raw_k = 0.0
+        else:
+            raw_k = 100.0 * (close0 - lowest_close) / (highest_close - lowest_close)
+
+        if self._slow_prev is None:
+            slow_val = raw_k
+        else:
+            slow_val = self._slow_prev + self._alpha_slow * (raw_k - self._slow_prev)
+
+        if self._signal_prev is None:
+            signal_val = slow_val
+        else:
+            signal_val = self._signal_prev + self._alpha_signal * (slow_val - self._signal_prev)
+
+        self.lines.main[0] = slow_val
+        self.lines.signal[0] = signal_val
+        self._slow_prev = slow_val
+        self._signal_prev = signal_val

backtrader/indicators/contrib/muv_nor_diff_cloud_indicator.py

@@ -0,0 +1,107 @@
+#!/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 (
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "MUVNorDiffCloudIndicator",
+]
+
+
+class MUVNorDiffCloudIndicator(Indicator):
+    """Calculate normalized DIFF cloud signals used by the strategy."""
+
+    lines = ("buy", "sell", "sma_res", "ema_res")
+    params = (
+        ("ma_period", 14),
+        ("momentum", 1),
+        ("kperiod", 14),
+    )
+
+    def __init__(self):
+        """Initialize SMA/EMA buffers and minimum bars required for reliable signals."""
+        price = self.data.close
+        self._sma = SimpleMovingAverage(price, period=max(1, int(self.p.ma_period)))
+        self._ema = ExponentialMovingAverage(price, period=max(1, int(self.p.ma_period)))
+        self.addminperiod(int(self.p.ma_period) + int(self.p.momentum) + int(self.p.kperiod) + 5)
+
+    def next(self):
+        """Compute cloud values for the current bar."""
+        momentum = max(1, int(self.p.momentum))
+        kperiod = max(2, int(self.p.kperiod))
+        sma_vals = []
+        ema_vals = []
+        for i in range(kperiod):
+            sma_vals.append(float(self._sma[-i]) - float(self._sma[-i - momentum]))
+            ema_vals.append(float(self._ema[-i]) - float(self._ema[-i - momentum]))
+        sma_cur = sma_vals[0]
+        ema_cur = ema_vals[0]
+        sma_max = max(sma_vals)
+        sma_min = min(sma_vals)
+        ema_max = max(ema_vals)
+        ema_min = min(ema_vals)
+        sma_range = sma_max - sma_min
+        ema_range = ema_max - ema_min
+        sma_res = 100.0 - 200.0 * (sma_max - sma_cur) / sma_range if sma_range > 0 else 100.0
+        ema_res = 100.0 - 200.0 * (ema_max - ema_cur) / ema_range if ema_range > 0 else 100.0
+        self.lines.sma_res[0] = sma_res
+        self.lines.ema_res[0] = ema_res
+        self.lines.buy[0] = 100.0 if sma_res == 100.0 or ema_res == 100.0 else 0.0
+        self.lines.sell[0] = -100.0 if sma_res == -100.0 or ema_res == -100.0 else 0.0
+
+    def once(self, start, end):
+        """Compute cloud values for a pre-allocated bar range in vectorized mode."""
+        momentum = max(1, int(self.p.momentum))
+        kperiod = max(2, int(self.p.kperiod))
+        sma = self._sma.array
+        ema = self._ema.array
+        buy = self.lines.buy.array
+        sell = self.lines.sell.array
+        sma_res_line = self.lines.sma_res.array
+        ema_res_line = self.lines.ema_res.array
+
+        for i in range(start, end):
+            sma_vals = []
+            ema_vals = []
+            for j in range(kperiod):
+                idx = i - j
+                prev = idx - momentum
+                if prev < 0:
+                    continue
+                sma_delta = float(sma[idx]) - float(sma[prev])
+                ema_delta = float(ema[idx]) - float(ema[prev])
+                if math.isfinite(sma_delta):
+                    sma_vals.append(sma_delta)
+                if math.isfinite(ema_delta):
+                    ema_vals.append(ema_delta)
+            if not sma_vals or not ema_vals:
+                sma_res = ema_res = 0.0
+            else:
+                sma_cur = sma_vals[0]
+                ema_cur = ema_vals[0]
+                sma_max = max(sma_vals)
+                sma_min = min(sma_vals)
+                ema_max = max(ema_vals)
+                ema_min = min(ema_vals)
+                sma_range = sma_max - sma_min
+                ema_range = ema_max - ema_min
+                sma_res = (
+                    100.0 - 200.0 * (sma_max - sma_cur) / sma_range if sma_range > 0 else 100.0
+                )
+                ema_res = (
+                    100.0 - 200.0 * (ema_max - ema_cur) / ema_range if ema_range > 0 else 100.0
+                )
+            sma_res_line[i] = sma_res
+            ema_res_line[i] = ema_res
+            buy[i] = 100.0 if sma_res == 100.0 or ema_res == 100.0 else 0.0
+            sell[i] = -100.0 if sma_res == -100.0 or ema_res == -100.0 else 0.0

backtrader/indicators/contrib/non_lag_dot_indicator.py

@@ -0,0 +1,124 @@
+#!/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__ = [
+    "NonLagDotIndicator",
+]
+
+
+PI = math.pi
+
+
+class NonLagDotIndicator(Indicator):
+    """Reconstructs NonLagDot from its MQ5 source.
+
+    Applies a weighted cosine kernel over SMA values to produce a non-lag MA,
+    then assigns color: 0=gray, 1=magenta(down), 2=green(up).
+    """
+
+    lines = ("nlm", "color")
+    params = (
+        ("length", 10),
+        ("filter_pts", 0),
+        ("deviation", 0.0),
+        ("point", 0.0001),
+    )
+
+    def __init__(self):
+        """Pre-compute kernel parameters and allocate indicator state."""
+        self._length = int(self.p.length)
+        coeff = 3 * PI
+        phase = self._length - 1
+        cycle = 4
+        self._len_total = int(self._length * cycle + phase)
+        self._dT1 = (2 * cycle - 1) / (cycle * self._length - 1)
+        self._dT2 = 1.0 / (phase - 1) if phase > 1 else 1.0
+        self._kd = 1.0 + self.p.deviation / 100.0
+        self._fi = int(self.p.filter_pts) * float(self.p.point)
+        self._coeff = coeff
+        self._phase = phase
+        self._cycle = cycle
+        self._trend = 0
+        self.addminperiod(self._length + self._len_total + 2)
+
+    def _calc_sma(self, ago):
+        length = self._length
+        total = 0.0
+        for i in range(length):
+            total += float(self.data.close[-(ago + i)])
+        return total / length
+
+    def next(self):
+        """Compute smoothed value and trend color for current bar.
+
+        The method calculates weighted SMA contributions, applies optional filtering,
+        and updates `nlm` and `color` lines.
+        """
+        len_total = self._len_total
+        coeff = self._coeff
+        phase = self._phase
+        fi = self._fi
+
+        # Build weighted sum using cosine kernel over SMA values
+        total_sum = 0.0
+        total_weight = 0.0
+        t = 0.0
+
+        for i in range(int(len_total)):
+            # SMA at offset i (0 = current bar)
+            sma_val = self._calc_sma(i)
+            if i <= phase - 1:
+                alfa = 1.0
+            else:
+                alfa = 1.0 / (1.0 + math.exp((i - phase + 0.5) * coeff / len_total))
+
+            beta = math.cos(PI * t)
+            g = 1.0 / (coeff * t + 1.0)
+            if t <= 0.5:
+                g = 1.0
+
+            total_sum += sma_val * beta * g * alfa
+            total_weight += beta * g * alfa
+
+            if t < 0.5:
+                t += self._dT2
+            elif t < len_total - 1:
+                t += self._dT1
+
+        nlm_val = self._kd * total_sum / total_weight if total_weight > 0 else 0.0
+
+        # Filter: if change < fi, hold previous value
+        prev_nlm = (
+            float(self.lines.nlm[-1])
+            if len(self.lines.nlm) > 1 and not math.isnan(float(self.lines.nlm[-1]))
+            else nlm_val
+        )
+        if fi > 0 and abs(nlm_val - prev_nlm) < fi:
+            nlm_val = prev_nlm
+
+        self.lines.nlm[0] = nlm_val
+
+        # Trend detection
+        trend = self._trend
+        if nlm_val - prev_nlm > fi:
+            trend = 1  # up
+        if prev_nlm - nlm_val > fi:
+            trend = -1  # down
+
+        # Color: 0=gray, 1=magenta(down), 2=green(up)
+        color = 0.0
+        if trend > 0:
+            color = 2.0
+        if trend < 0:
+            color = 1.0
+
+        self.lines.color[0] = color
+        self._trend = trend

backtrader/indicators/contrib/nrtr_extr_indicator.py

@@ -0,0 +1,95 @@
+#!/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 Indicator
+
+__all__ = [
+    "NRTRExtrIndicator",
+]
+
+
+class NRTRExtrIndicator(Indicator):
+    """Reconstructs NRTR_extr indicator from its MQ5 source.
+
+    Same as NRTR but uses high/low extremes instead of close for price tracking.
+    In uptrend: price = max(price, high[bar]); check close < value.
+    In downtrend: price = min(price, low[bar]); check close > value.
+    On flip up: price = low[bar], value = price*(1-dK).
+    On flip down: price = high[bar], value = price*(1+dK).
+    """
+
+    lines = ("trend_up", "trend_down", "sign_up", "sign_down")
+    params = (
+        ("iperiod", 10),
+        ("idig", 0),
+    )
+
+    def __init__(self):
+        """Initialize internal NRTR state and warm-up period."""
+        self._period = int(self.p.iperiod)
+        self._idig = int(self.p.idig)
+        self._trend = 0
+        self._trend_prev = 0
+        self._price = 0.0
+        self._value = 0.0
+        self._first = True
+        self.addminperiod(self._period + 2)
+
+    def next(self):
+        """Update trend state, channel values, and signal lines."""
+        period = self._period
+
+        if self._first:
+            self._trend_prev = 0
+            self._price = float(self.data.close[0])
+            self._value = self._price
+            self._first = False
+
+        self._trend = self._trend_prev
+        price = self._price
+        value = self._value
+
+        avg_range = 0.0
+        for i in range(period):
+            avg_range += abs(float(self.data.high[-i]) - float(self.data.low[-i]))
+        avg_range /= period
+
+        digits_diff = 5 - self._idig
+        dK = avg_range / pow(10, digits_diff) if pow(10, digits_diff) != 0 else avg_range
+
+        cur_close = float(self.data.close[0])
+        cur_high = float(self.data.high[0])
+        cur_low = float(self.data.low[0])
+
+        if self._trend >= 0:
+            price = max(price, cur_high)  # uses high instead of close
+            value = max(value, price * (1.0 - dK))
+            if cur_close < value:
+                price = cur_high  # uses high
+                value = price * (1.0 + dK)
+                self._trend = -1
+        elif self._trend <= 0:
+            price = min(price, cur_low)  # uses low instead of close
+            value = min(value, price * (1.0 + dK))
+            if cur_close > value:
+                price = cur_low  # uses low
+                value = price * (1.0 - dK)
+                self._trend = 1
+
+        tu = value if self._trend > 0 else 0.0
+        td = value if self._trend < 0 else 0.0
+        su = tu if self._trend_prev < 0 and self._trend > 0 else 0.0
+        sd = td if self._trend_prev > 0 and self._trend < 0 else 0.0
+
+        self._trend_prev = self._trend
+        self._price = price
+        self._value = value
+
+        self.lines.trend_up[0] = tu
+        self.lines.trend_down[0] = td
+        self.lines.sign_up[0] = su
+        self.lines.sign_down[0] = sd

backtrader/indicators/contrib/nrtr_indicator.py

@@ -0,0 +1,95 @@
+#!/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 Indicator
+
+__all__ = [
+    "NRTRIndicator",
+]
+
+
+class NRTRIndicator(Indicator):
+    """Reconstructs NRTR indicator from its MQ5 source.
+
+    Uses iPeriod average range to compute dK scaling factor.
+    Tracks price (close-based) and value with trend ratchet.
+    When close drops below value in uptrend → flip to downtrend.
+    When close rises above value in downtrend → flip to uptrend.
+    4 buffers: TrendUp(0), TrendDown(1), SignUp(2), SignDown(3).
+    """
+
+    lines = ("trend_up", "trend_down", "sign_up", "sign_down")
+    params = (
+        ("iperiod", 10),
+        ("idig", 0),
+    )
+
+    def __init__(self):
+        """Initialize the NRTR period, trend state and trailing value buffers."""
+        self._period = int(self.p.iperiod)
+        self._idig = int(self.p.idig)
+        self._trend = 0
+        self._trend_prev = 0
+        self._price = 0.0
+        self._value = 0.0
+        self._first = True
+        self.addminperiod(self._period + 2)
+
+    def next(self):
+        """Update the trailing value, detect trend flips, and emit buffers."""
+        period = self._period
+
+        if self._first:
+            self._trend_prev = 0
+            self._price = float(self.data.close[0])
+            self._value = self._price
+            self._first = False
+
+        self._trend = self._trend_prev
+        price = self._price
+        value = self._value
+
+        # Average range
+        avg_range = 0.0
+        for i in range(period):
+            avg_range += abs(float(self.data.high[-i]) - float(self.data.low[-i]))
+        avg_range /= period
+
+        # dK scaling (original uses EURUSD digits but we simplify)
+        digits_diff = 5 - self._idig  # approximate
+        dK = avg_range / pow(10, digits_diff) if pow(10, digits_diff) != 0 else avg_range
+
+        cur_close = float(self.data.close[0])
+
+        if self._trend >= 0:
+            price = max(price, cur_close)
+            value = max(value, price * (1.0 - dK))
+            if cur_close < value:
+                price = cur_close
+                value = price * (1.0 + dK)
+                self._trend = -1
+        elif self._trend <= 0:
+            price = min(price, cur_close)
+            value = min(value, price * (1.0 + dK))
+            if cur_close > value:
+                price = cur_close
+                value = price * (1.0 - dK)
+                self._trend = 1
+
+        tu = value if self._trend > 0 else 0.0
+        td = value if self._trend < 0 else 0.0
+        su = tu if self._trend_prev < 0 and self._trend > 0 else 0.0
+        sd = td if self._trend_prev > 0 and self._trend < 0 else 0.0
+
+        self._trend_prev = self._trend
+        self._price = price
+        self._value = value
+
+        self.lines.trend_up[0] = tu
+        self.lines.trend_down[0] = td
+        self.lines.sign_up[0] = su
+        self.lines.sign_down[0] = sd

backtrader/indicators/contrib/p_channel_system.py

@@ -0,0 +1,40 @@
+#!/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 Indicator
+
+__all__ = [
+    "PChannelSystem",
+]
+
+
+class PChannelSystem(Indicator):
+    """Indicator that classifies current bar position versus rolling channel bounds."""
+
+    lines = ("color",)
+    params = (
+        ("period", 20),
+        ("shift", 2),
+    )
+
+    def __init__(self):
+        """Initialize warmup requirements for the configured rolling period."""
+        self.addminperiod(int(self.p.period) + int(self.p.shift) + 3)
+
+    def next(self):
+        """Compute channel colors from rolling high/low and current candle body."""
+        shift = int(self.p.shift)
+        hh = max(float(self.data.high[-(shift + i)]) for i in range(int(self.p.period)))
+        ll = min(float(self.data.low[-(shift + i)]) for i in range(int(self.p.period)))
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        color = 2.0
+        if close > hh:
+            color = 4.0 if open_ <= close else 3.0
+        if close < ll:
+            color = 0.0 if open_ > close else 1.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/percent_envelope.py

@@ -0,0 +1,37 @@
+#!/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 (
+    Indicator,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "PercentEnvelope",
+]
+
+
+class PercentEnvelope(Indicator):
+    """Percent envelope built from a moving-average midpoint."""
+
+    lines = ("top", "bot")
+    params = (
+        ("period", 14),
+        ("perc", 1.0),
+    )
+
+    def __init__(self):
+        """Initialize MA and enforce minimum lookback warm-up."""
+        self.ma = SimpleMovingAverage(self.data, period=int(self.p.period))
+        self.addminperiod(int(self.p.period))
+
+    def next(self):
+        """Update upper/lower envelope boundaries for the current bar."""
+        offset = float(self.p.perc) / 100.0
+        ma = float(self.ma[0])
+        self.lines.top[0] = ma * (1.0 + offset)
+        self.lines.bot[0] = ma * (1.0 - offset)

backtrader/indicators/contrib/percentage_crossover_channel.py

@@ -0,0 +1,47 @@
+#!/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 Indicator
+
+__all__ = [
+    "PercentageCrossoverChannel",
+]
+
+
+class PercentageCrossoverChannel(Indicator):
+    """Percent-based dynamic channel indicator.
+
+    The middle line is gradually adjusted toward current price with separate
+    upper/lower bands derived from the configured percentage distance.
+    """
+
+    lines = ("upper", "middle", "lower")
+    params = (("percent", 50.0),)
+
+    def __init__(self):
+        """Initialize percent offsets and minimum warm-up settings."""
+        self.addminperiod(2)
+        percent = max(self.p.percent, 0.001) / 100.0
+        self.plus_value = 1 + percent / 100.0
+        self.minus_value = 1 - percent / 100.0
+
+    def next(self):
+        """Update middle, upper, and lower channel lines for the current bar."""
+        price = float(self.data.close[0])
+        if len(self.data) == 1 or self.lines.middle[-1] != self.lines.middle[-1]:
+            middle = price
+        else:
+            prev_middle = float(self.lines.middle[-1])
+            if price * self.minus_value > prev_middle:
+                middle = price * self.minus_value
+            elif price * self.plus_value < prev_middle:
+                middle = price * self.plus_value
+            else:
+                middle = prev_middle
+        self.lines.middle[0] = middle
+        self.lines.upper[0] = middle * self.plus_value
+        self.lines.lower[0] = middle * self.minus_value

backtrader/indicators/contrib/pivot_zig_zag_proxy.py

@@ -0,0 +1,47 @@
+#!/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 Indicator
+
+__all__ = [
+    "PivotZigZagProxy",
+]
+
+
+class PivotZigZagProxy(Indicator):
+    """Compact pivot and zigzag proxy indicator used by the strategy.
+
+    It tracks the nearest recent high/low pivot pairs over a configurable depth
+    and emits them as four separate output lines.
+    """
+
+    lines = ("high0", "low0", "high1", "low1")
+    params = (("depth", 12),)
+
+    def __init__(self):
+        """Initialize minimum required bars for pivot calculation."""
+        self.addminperiod(self.p.depth * 3)
+
+    def next(self):
+        """Compute and expose the most recent two high and two low pivot levels."""
+        pivots = []
+        lookback = min(len(self.data) - 1, self.p.depth * 8)
+        for idx in range(2, lookback):
+            high = float(self.data.high[-idx])
+            low = float(self.data.low[-idx])
+            if high >= float(self.data.high[-idx - 1]) and high >= float(self.data.high[-idx + 1]):
+                pivots.append(("high", high, idx))
+            if low <= float(self.data.low[-idx - 1]) and low <= float(self.data.low[-idx + 1]):
+                pivots.append(("low", low, idx))
+        pivots.sort(key=lambda item: item[2])
+        pivots = pivots[:4]
+        highs = [value for kind, value, _ in pivots if kind == "high"]
+        lows = [value for kind, value, _ in pivots if kind == "low"]
+        self.lines.high0[0] = highs[0] if len(highs) > 0 else 0.0
+        self.lines.high1[0] = highs[1] if len(highs) > 1 else 0.0
+        self.lines.low0[0] = lows[0] if len(lows) > 0 else 0.0
+        self.lines.low1[0] = lows[1] if len(lows) > 1 else 0.0