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

backtrader/indicators/contrib/color_step_xccx_indicator.py

@@ -0,0 +1,193 @@
+#!/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 (
+    EMA,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ColorStepXCCXIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average mode name to a Backtrader MA class."""
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SMA
+    if mode in {"ema", "mode_ema"}:
+        return EMA
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Return the selected price series from data for indicator calculations.
+
+    Args:
+        data: Backtrader data feed.
+        mode: Price selector token from strategy configuration.
+
+    Returns:
+        A Backtrader data line used as input to indicators.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_open", "open"}:
+        return data.open
+    if price_mode in {"price_high", "high"}:
+        return data.high
+    if price_mode in {"price_low", "low"}:
+        return data.low
+    if price_mode in {"price_median", "median"}:
+        return (data.high + data.low) / 2.0
+    if price_mode in {"price_typical", "typical"}:
+        return (data.high + data.low + data.close) / 3.0
+    if price_mode in {"price_weighted", "weighted"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    return data.close
+
+
+class ColorStepXCCXIndicator(Indicator):
+    """Compute fast/slow XCCX channel lines for directional step signals."""
+
+    lines = (
+        "mplus",
+        "mminus",
+    )
+    params = (
+        ("dsmooth_method", "jjma"),
+        ("dperiod", 30),
+        ("dphase", 100),
+        ("msmooth_method", "t3"),
+        ("mperiod", 7),
+        ("mphase", 15),
+        ("ipc", "price_typical"),
+        ("step_size_fast", 5),
+        ("step_size_slow", 30),
+    )
+
+    def __init__(self):
+        """Initialize smoothed base/offset series and running channel states."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        self._base = resolve_ma_class(self.p.dsmooth_method)(price_line, period=self.p.dperiod)
+        self._up = resolve_ma_class(self.p.msmooth_method)(
+            price_line - self._base, period=self.p.mperiod
+        )
+        self._dn = resolve_ma_class(self.p.msmooth_method)(
+            abs(price_line - self._base), period=self.p.mperiod
+        )
+        self._fmin1 = 999999.0
+        self._fmax1 = -999999.0
+        self._smin1 = 999999.0
+        self._smax1 = -999999.0
+        self._ftrend = 0
+        self._strend = 0
+        self.addminperiod(self.p.dperiod + self.p.mperiod + 5)
+
+    def next(self):
+        """Update fast and slow channel lines on the next bar."""
+        xupccx = float(self._up[0])
+        xdnccx = float(self._dn[0])
+        xccx = 100.0 * xupccx / xdnccx if xupccx != 0.0 and xdnccx != 0.0 else 0.0
+        fmax0 = xccx + 2 * float(self.p.step_size_fast)
+        fmin0 = xccx - 2 * float(self.p.step_size_fast)
+        if xccx > self._fmax1:
+            self._ftrend = 1
+        if xccx < self._fmin1:
+            self._ftrend = -1
+        if self._ftrend > 0 and fmin0 < self._fmin1:
+            fmin0 = self._fmin1
+        if self._ftrend < 0 and fmax0 > self._fmax1:
+            fmax0 = self._fmax1
+        smax0 = xccx + 2 * float(self.p.step_size_slow)
+        smin0 = xccx - 2 * float(self.p.step_size_slow)
+        if xccx > self._smax1:
+            self._strend = 1
+        if xccx < self._smin1:
+            self._strend = -1
+        if self._strend > 0 and smin0 < self._smin1:
+            smin0 = self._smin1
+        if self._strend < 0 and smax0 > self._smax1:
+            smax0 = self._smax1
+        self.lines.mplus[0] = (
+            fmin0 + float(self.p.step_size_fast)
+            if self._ftrend > 0
+            else fmax0 - float(self.p.step_size_fast)
+        )
+        self.lines.mminus[0] = (
+            smin0 + float(self.p.step_size_slow)
+            if self._strend > 0
+            else smax0 - float(self.p.step_size_slow)
+        )
+        self._fmin1 = fmin0
+        self._fmax1 = fmax0
+        self._smin1 = smin0
+        self._smax1 = smax0
+
+    def once(self, start, end):
+        """Compute channel lines for vectorized/cached bars from `start` to `end`."""
+        up_array = self._up.array
+        dn_array = self._dn.array
+        mplus_line = self.lines.mplus.array
+        mminus_line = self.lines.mminus.array
+        for line in (mplus_line, mminus_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        fmin1 = 999999.0
+        fmax1 = -999999.0
+        smin1 = 999999.0
+        smax1 = -999999.0
+        ftrend = 0
+        strend = 0
+        fast_step = float(self.p.step_size_fast)
+        slow_step = float(self.p.step_size_slow)
+        actual_end = min(end, len(up_array), len(dn_array))
+        for i in range(start, actual_end):
+            xupccx = float(up_array[i])
+            xdnccx = float(dn_array[i])
+            xccx = 100.0 * xupccx / xdnccx if xupccx != 0.0 and xdnccx != 0.0 else 0.0
+            fmax0 = xccx + 2.0 * fast_step
+            fmin0 = xccx - 2.0 * fast_step
+            if xccx > fmax1:
+                ftrend = 1
+            if xccx < fmin1:
+                ftrend = -1
+            if ftrend > 0 and fmin0 < fmin1:
+                fmin0 = fmin1
+            if ftrend < 0 and fmax0 > fmax1:
+                fmax0 = fmax1
+
+            smax0 = xccx + 2.0 * slow_step
+            smin0 = xccx - 2.0 * slow_step
+            if xccx > smax1:
+                strend = 1
+            if xccx < smin1:
+                strend = -1
+            if strend > 0 and smin0 < smin1:
+                smin0 = smin1
+            if strend < 0 and smax0 > smax1:
+                smax0 = smax1
+
+            mplus_line[i] = fmin0 + fast_step if ftrend > 0 else fmax0 - fast_step
+            mminus_line[i] = smin0 + slow_step if strend > 0 else smax0 - slow_step
+            fmin1 = fmin0
+            fmax1 = fmax0
+            smin1 = smin0
+            smax1 = smax0
+
+        self._fmin1 = fmin1
+        self._fmax1 = fmax1
+        self._smin1 = smin1
+        self._smax1 = smax1
+        self._ftrend = ftrend
+        self._strend = strend

backtrader/indicators/contrib/color_x2_ma.py

@@ -0,0 +1,49 @@
+#!/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,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "ColorX2MA",
+]
+
+
+class ColorX2MA(Indicator):
+    """Indicator that outputs smoothed MA value and directional color index."""
+
+    lines = ("value", "color_idx")
+    params = (
+        ("length1", 12),
+        ("length2", 5),
+    )
+
+    def __init__(self):
+        """Initialize MA stacks and minimum period."""
+        ma1 = SimpleMovingAverage(self.data.close, period=max(2, self.p.length1))
+        ma2 = SimpleMovingAverage(ma1, period=max(2, self.p.length2))
+        self.lines.value = ma2
+        self.addminperiod(self.p.length1 + self.p.length2 + 2)
+
+    def next(self):
+        """Update color index based on value momentum."""
+        current = float(self.lines.value[0])
+        prev = (
+            float(self.lines.value[-1])
+            if len(self) > 1 and math.isfinite(float(self.lines.value[-1]))
+            else current
+        )
+        color = 0.0
+        if prev < current:
+            color = 1.0
+        elif prev > current:
+            color = 2.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/color_x_derivative.py

@@ -0,0 +1,63 @@
+#!/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__ = [
+    "ColorXDerivative",
+]
+
+
+class ColorXDerivative(Indicator):
+    """Smoothed price-derivative indicator with a momentum color state.
+
+    Computes the average rate of change of a weighted price over ``i_slowing``
+    bars, smoothed across ``xlength`` windows, and classifies it into a color
+    index: rising/falling while positive (0/1) or negative (3/4), with 2 as a
+    neutral state.
+    """
+
+    lines = ("value", "color_idx")
+    params = (
+        ("i_slowing", 34),
+        ("xlength", 15),
+    )
+
+    def __init__(self):
+        """Set the minimum period to cover the slowing and smoothing windows."""
+        self.addminperiod(max(self.p.i_slowing + 2, self.p.xlength + 2))
+
+    def _price(self, ago=0):
+        return (
+            float(self.data.high[ago])
+            + float(self.data.low[ago])
+            + 2.0 * float(self.data.close[ago])
+        ) / 4.0
+
+    def next(self):
+        """Compute the smoothed derivative value and its color state.
+
+        Stores the smoothed derivative on the ``value`` line and a color index on
+        ``color_idx`` reflecting whether the value is rising or falling above or
+        below zero relative to the previous bar.
+        """
+        der = 100.0 * (self._price(0) - self._price(-self.p.i_slowing)) / float(self.p.i_slowing)
+        window = [
+            100.0
+            * (self._price(-i) - self._price(-(i + self.p.i_slowing)))
+            / float(self.p.i_slowing)
+            for i in range(self.p.xlength)
+        ]
+        smooth = sum(window) / float(len(window)) if window else der
+        self.lines.value[0] = smooth
+        prev = float(self.lines.value[-1]) if len(self) > 1 else smooth
+        color = 2.0
+        if smooth > 0:
+            color = 0.0 if prev <= smooth else 1.0
+        elif smooth < 0:
+            color = 4.0 if prev >= smooth else 3.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/color_zerolag_de_marker.py

@@ -0,0 +1,84 @@
+#!/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 (
+    DeMarkerRollingIndicator,
+    Indicator,
+)
+
+__all__ = [
+    "ColorZerolagDeMarker",
+]
+
+
+class ColorZerolagDeMarker(Indicator):
+    """Blend five weighted DeMarker oscillators into fast and slow trend lines."""
+
+    lines = ("fast", "slow")
+    params = (
+        ("smoothing", 15),
+        ("factor1", 0.05),
+        ("demarker_period1", 8),
+        ("factor2", 0.1),
+        ("demarker_period2", 21),
+        ("factor3", 0.16),
+        ("demarker_period3", 34),
+        ("factor4", 0.26),
+        ("demarker_period4", 55),
+        ("factor5", 0.43),
+        ("demarker_period5", 89),
+    )
+
+    def __init__(self):
+        """Build the five DeMarker sub-indicators and smoothing constants."""
+        periods = [
+            int(self.p.demarker_period1),
+            int(self.p.demarker_period2),
+            int(self.p.demarker_period3),
+            int(self.p.demarker_period4),
+            int(self.p.demarker_period5),
+        ]
+        self.addminperiod(3 * max(periods) + 5)
+        self.dem1 = DeMarkerRollingIndicator(self.data, period=int(self.p.demarker_period1))
+        self.dem2 = DeMarkerRollingIndicator(self.data, period=int(self.p.demarker_period2))
+        self.dem3 = DeMarkerRollingIndicator(self.data, period=int(self.p.demarker_period3))
+        self.dem4 = DeMarkerRollingIndicator(self.data, period=int(self.p.demarker_period4))
+        self.dem5 = DeMarkerRollingIndicator(self.data, period=int(self.p.demarker_period5))
+        self.smooth_const = (float(self.p.smoothing) - 1.0) / float(self.p.smoothing)
+        self._initialized = False
+
+    def next(self):
+        """Weight DeMarker values into a fast trend and smoothed slow trend."""
+        values = [
+            float(self.dem1[0]),
+            float(self.dem2[0]),
+            float(self.dem3[0]),
+            float(self.dem4[0]),
+            float(self.dem5[0]),
+        ]
+        if any(not math.isfinite(value) for value in values):
+            self.lines.fast[0] = float("nan")
+            self.lines.slow[0] = float("nan")
+            return
+        osc1 = float(self.p.factor1) * values[0]
+        osc2 = float(self.p.factor2) * values[1]
+        osc3 = float(self.p.factor3) * values[2]
+        osc4 = float(self.p.factor4) * values[3]
+        osc5 = float(self.p.factor5) * values[4]
+        fast_trend = osc1 + osc2 + osc3 + osc4 + osc5
+        if not self._initialized:
+            slow_trend = fast_trend / float(self.p.smoothing)
+            self._initialized = True
+        else:
+            slow_trend = (
+                fast_trend / float(self.p.smoothing)
+                + float(self.lines.slow[-1]) * self.smooth_const
+            )
+        self.lines.fast[0] = fast_trend
+        self.lines.slow[0] = slow_trend

backtrader/indicators/contrib/corrected_average_indicator.py

@@ -0,0 +1,127 @@
+#!/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 (
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    StandardDeviation,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "CorrectedAverageIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Return the backtrader moving-average class for a method name.
+
+    Args:
+        name: MA method name (sma, ema, smma, or a weighted fallback).
+
+    Returns:
+        The corresponding backtrader moving-average indicator class.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SimpleMovingAverage
+    if mode in {"ema", "mode_ema"}:
+        return ExponentialMovingAverage
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Return the price line selected by an MT5 applied-price mode.
+
+    Args:
+        data: The data feed providing OHLC lines.
+        mode: Applied-price mode name (e.g. ``price_close``, ``price_median``).
+
+    Returns:
+        The line or line expression for the requested applied price; defaults
+        to the close line for unrecognized modes.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_open", "open"}:
+        return data.open
+    if price_mode in {"price_high", "high"}:
+        return data.high
+    if price_mode in {"price_low", "low"}:
+        return data.low
+    if price_mode in {"price_median", "median"}:
+        return (data.high + data.low) / 2.0
+    if price_mode in {"price_typical", "typical"}:
+        return (data.high + data.low + data.close) / 3.0
+    if price_mode in {"price_weighted", "weighted"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    return data.close
+
+
+class CorrectedAverageIndicator(Indicator):
+    """Ehlers-style adaptive Corrected Average with event and vectorized modes."""
+
+    lines = ("corrected",)
+    params = (
+        ("ma_method", "sma"),
+        ("length", 12),
+        ("applied_price", "price_close"),
+    )
+
+    def __init__(self):
+        """Build the base MA and standard deviation and set the min period."""
+        price_line = resolve_price_line(self.data, self.p.applied_price)
+        self._ma = resolve_ma_class(self.p.ma_method)(price_line, period=self.p.length)
+        self._std = StandardDeviation(price_line, period=self.p.length)
+        self.addminperiod(int(self.p.length) + 3)
+
+    def next(self):
+        """Compute the corrected average for the current bar."""
+        ma = float(self._ma[0])
+        std = float(self._std[0])
+        prev = float(self.lines.corrected[-1]) if len(self) > 0 else ma
+        if prev != prev:
+            prev = ma
+        v1 = std**2
+        v2 = (prev - ma) ** 2
+        if v2 < v1 or v2 == 0:
+            k = 0.0
+        else:
+            k = 1.0 - v1 / v2
+        self.lines.corrected[0] = prev + k * (ma - prev)
+
+    def once(self, start, end):
+        """Vectorized corrected-average computation over the array index range.
+
+        Args:
+            start: Start index (inclusive) of the range to compute.
+            end: End index (exclusive) of the range to compute.
+        """
+        ma_array = self._ma.array
+        std_array = self._std.array
+        corrected_line = self.lines.corrected.array
+        while len(corrected_line) < end:
+            corrected_line.append(float("nan"))
+
+        prev = None
+        actual_end = min(end, len(ma_array), len(std_array))
+        for i in range(start, actual_end):
+            ma = float(ma_array[i])
+            std = float(std_array[i])
+            previous = ma if prev is None else prev
+            v1 = std**2
+            v2 = (previous - ma) ** 2
+            if v2 < v1 or v2 == 0:
+                k = 0.0
+            else:
+                k = 1.0 - v1 / v2
+            value = previous + k * (ma - previous)
+            corrected_line[i] = value
+            prev = value

backtrader/indicators/contrib/darvas_boxes_system.py

@@ -0,0 +1,73 @@
+#!/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__ = [
+    "DarvasBoxesSystem",
+]
+
+
+class DarvasBoxesSystem(Indicator):
+    """Indicator that emits Darvas box color states from high/low progression."""
+
+    lines = ("color",)
+    params = (
+        ("symmetry", True),
+        ("shift", 2),
+    )
+
+    def __init__(self):
+        """Initialize the indicator state and ensure required warmup bars."""
+        self.addminperiod(int(self.p.shift) + 8)
+        self.state = 0
+        self.box_top = None
+        self.box_bottom = None
+
+    def next(self):
+        """Update the running Darvas box and emit the discrete color signal."""
+        if self.box_top is None:
+            self.box_top = float(self.data.high[-1])
+            self.box_bottom = float(self.data.low[-1])
+            self.state = 1
+        bar_high = float(self.data.high[0])
+        bar_low = float(self.data.low[0])
+        if self.state == 1:
+            self.box_top = bar_high
+            if self.p.symmetry:
+                self.box_bottom = bar_low
+        elif self.state == 2:
+            if self.box_top <= bar_high:
+                self.box_top = bar_high
+        elif self.state == 3:
+            if self.box_top > bar_high:
+                self.box_bottom = bar_low
+            else:
+                self.box_top = bar_high
+        elif self.state == 4:
+            if self.box_top > bar_high:
+                if self.box_bottom >= bar_low:
+                    self.box_bottom = bar_low
+            else:
+                self.box_top = bar_high
+        elif self.state == 5:
+            if self.box_top > bar_high:
+                if self.box_bottom >= bar_low:
+                    self.box_bottom = bar_low
+            else:
+                self.box_top = bar_high
+            self.state = 0
+        self.state += 1
+        shift = int(self.p.shift)
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        color = 2.0
+        if len(self.data) > shift and close > self.box_top:
+            color = 4.0 if open_ < close else 3.0
+        if len(self.data) > shift and close < self.box_bottom:
+            color = 0.0 if open_ > close else 1.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/dema_range_channel_color.py

@@ -0,0 +1,42 @@
+#!/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 (
+    DoubleExponentialMovingAverage,
+    Indicator,
+)
+
+__all__ = [
+    "DemaRangeChannelColor",
+]
+
+
+class DemaRangeChannelColor(Indicator):
+    """Indicator computing DEMA-based upper/lower range channels with a color index for breakout direction."""
+
+    lines = ("color_idx", "upper", "lower")
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Initialize DEMA channels from high/low inputs."""
+        self.upper_dema = DoubleExponentialMovingAverage(self.data.high, period=self.p.period)
+        self.lower_dema = DoubleExponentialMovingAverage(self.data.low, period=self.p.period)
+
+    def next(self):
+        """Set the upper, lower, and color_idx line values based on close position relative to DEMA band."""
+        upper = float(self.upper_dema[0])
+        lower = float(self.lower_dema[0])
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        self.lines.upper[0] = upper
+        self.lines.lower[0] = lower
+        color = 4.0
+        if close > upper:
+            color = 3.0 if close >= open_ else 2.0
+        elif close < lower:
+            color = 0.0 if close <= open_ else 1.0
+        self.lines.color_idx[0] = color