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

backtrader/indicators/contrib/color_j_variation_indicator.py

@@ -0,0 +1,53 @@
+#!/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__ = [
+    "ColorJVariationIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average name to 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
+
+
+class ColorJVariationIndicator(Indicator):
+    """Indicator deriving a custom color variation series from MA residuals."""
+
+    lines = ("value",)
+    params = (
+        ("period_", 12),
+        ("ma_method_", "sma"),
+        ("jlength_", 3),
+        ("jphase_", 100),
+    )
+
+    def __init__(self):
+        """Build nested moving averages and assign EMA-smoothed output line."""
+        ma_cls = resolve_ma_class(self.p.ma_method_)
+        ma1 = ma_cls(self.data.close, period=self.p.period_)
+        residual1 = self.data.close - ma1
+        ma2 = ma_cls(residual1, period=self.p.period_)
+        residual2 = self.data.close - ma1 - ma2
+        ma3 = ma_cls(residual2, period=self.p.period_)
+        self.lines.value = EMA(ma3, period=max(1, int(self.p.jlength_)))
+        self.addminperiod(self.p.period_ * 3 + self.p.jlength_ + 5)

backtrader/indicators/contrib/color_metro_de_marker_indicator.py

@@ -0,0 +1,78 @@
+#!/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 (
+    DeMarkerIndicator,
+    Indicator,
+)
+
+__all__ = [
+    "ColorMetroDeMarkerIndicator",
+]
+
+
+class ColorMetroDeMarkerIndicator(Indicator):
+    """Colour Metro DeMarker indicator: derives fast/slow adaptive trend lines from the DeM oscillator."""
+
+    lines = ("fast_line", "slow_line", "demarker")
+    params = (
+        ("period_demarker", 7),
+        ("step_size_fast", 5),
+        ("step_size_slow", 15),
+    )
+
+    def __init__(self):
+        """Initialize DeMarker instance, set minperiod, reset channel tracking vars."""
+        self.dem = DeMarkerIndicator(self.data, period=int(self.p.period_demarker))
+        self.addminperiod(int(self.p.period_demarker) + 3)
+        self._fmin1 = 999999.0
+        self._fmax1 = -999999.0
+        self._smin1 = 999999.0
+        self._smax1 = -999999.0
+        self._ftrend = 0
+        self._strend = 0
+
+    def next(self):
+        """Compute fast_line, slow_line and demarker from DeM value using step-based channel logic."""
+        dem0 = float(self.dem[0]) * 100.0
+        fmax0 = dem0 + 2.0 * float(self.p.step_size_fast)
+        fmin0 = dem0 - 2.0 * float(self.p.step_size_fast)
+        if dem0 > self._fmax1:
+            self._ftrend = 1
+        if dem0 < 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 = dem0 + 2.0 * float(self.p.step_size_slow)
+        smin0 = dem0 - 2.0 * float(self.p.step_size_slow)
+        if dem0 > self._smax1:
+            self._strend = 1
+        if dem0 < 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
+        fast_line = (
+            fmin0 + float(self.p.step_size_fast)
+            if self._ftrend > 0
+            else fmax0 - float(self.p.step_size_fast)
+        )
+        slow_line = (
+            smin0 + float(self.p.step_size_slow)
+            if self._strend > 0
+            else smax0 - float(self.p.step_size_slow)
+        )
+        self.lines.fast_line[0] = fast_line
+        self.lines.slow_line[0] = slow_line
+        self.lines.demarker[0] = dem0
+        self._fmin1 = fmin0
+        self._fmax1 = fmax0
+        self._smin1 = smin0
+        self._smax1 = smax0

backtrader/indicators/contrib/color_metro_stochastic_indicator.py

@@ -0,0 +1,93 @@
+#!/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,
+    Stochastic,
+)
+
+__all__ = [
+    "ColorMetroStochasticIndicator",
+]
+
+
+class ColorMetroStochasticIndicator(Indicator):
+    """Indicator producing adaptive fast/slow ColorMETRO stochastic levels."""
+
+    lines = ("fast_line", "slow_line", "stochastic")
+    params = (
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+        ("ma_method", "simple"),
+        ("step_size_fast", 5),
+        ("step_size_slow", 15),
+    )
+
+    def __init__(self):
+        """Initialize Stochastic source and internal trend tracking state."""
+        self.stoch = Stochastic(
+            self.data,
+            period=int(self.p.k_period),
+            period_dfast=int(self.p.slowing),
+            period_dslow=int(self.p.d_period),
+            movav=(
+                SimpleMovingAverage
+                if str(self.p.ma_method).lower() == "simple"
+                else ExponentialMovingAverage
+            ),
+        )
+        self.addminperiod(int(self.p.k_period) + int(self.p.d_period) + int(self.p.slowing) + 3)
+        self._fmin1 = 999999.0
+        self._fmax1 = -999999.0
+        self._smin1 = 999999.0
+        self._smax1 = -999999.0
+        self._ftrend = 0
+        self._strend = 0
+
+    def next(self):
+        """Update fast/slow adaptive lines and push current values."""
+        stoch0 = float(self.stoch.percD[0])
+        fmax0 = stoch0 + 2.0 * float(self.p.step_size_fast)
+        fmin0 = stoch0 - 2.0 * float(self.p.step_size_fast)
+        if stoch0 > self._fmax1:
+            self._ftrend = 1
+        if stoch0 < 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 = stoch0 + 2.0 * float(self.p.step_size_slow)
+        smin0 = stoch0 - 2.0 * float(self.p.step_size_slow)
+        if stoch0 > self._smax1:
+            self._strend = 1
+        if stoch0 < 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
+        fast_line = (
+            fmin0 + float(self.p.step_size_fast)
+            if self._ftrend > 0
+            else fmax0 - float(self.p.step_size_fast)
+        )
+        slow_line = (
+            smin0 + float(self.p.step_size_slow)
+            if self._strend > 0
+            else smax0 - float(self.p.step_size_slow)
+        )
+        self.lines.fast_line[0] = fast_line
+        self.lines.slow_line[0] = slow_line
+        self.lines.stochastic[0] = stoch0
+        self._fmin1 = fmin0
+        self._fmax1 = fmax0
+        self._smin1 = smin0
+        self._smax1 = smax0

backtrader/indicators/contrib/color_metro_wpr_indicator.py

@@ -0,0 +1,85 @@
+#!/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 (
+    Highest,
+    Indicator,
+    Lowest,
+)
+
+__all__ = [
+    "ColorMetroWprIndicator",
+]
+
+
+class ColorMetroWprIndicator(Indicator):
+    """ColorMETRO step lines (fast/slow NRTR) computed over Williams %R."""
+
+    lines = ("fast_line", "slow_line", "wpr_shifted")
+    params = (
+        ("period_wpr", 7),
+        ("step_size_fast", 5),
+        ("step_size_slow", 15),
+    )
+
+    def __init__(self):
+        """Build the Highest/Lowest sub-indicators and reset NRTR step state."""
+        period = int(self.p.period_wpr)
+        self.highest = Highest(self.data.high, period=period)
+        self.lowest = Lowest(self.data.low, period=period)
+        self.addminperiod(period + 3)
+        self._fmin1 = 999999.0
+        self._fmax1 = -999999.0
+        self._smin1 = 999999.0
+        self._smax1 = -999999.0
+        self._ftrend = 0
+        self._strend = 0
+
+    def next(self):
+        """Update the fast and slow NRTR step lines from the current %R value."""
+        highest = float(self.highest[0])
+        lowest = float(self.lowest[0])
+        close = float(self.data.close[0])
+        span = highest - lowest
+        wpr0 = 50.0 if span == 0 else 100.0 * (close - lowest) / span
+        fmax0 = wpr0 + 2.0 * float(self.p.step_size_fast)
+        fmin0 = wpr0 - 2.0 * float(self.p.step_size_fast)
+        if wpr0 > self._fmax1:
+            self._ftrend = 1
+        if wpr0 < 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 = wpr0 + 2.0 * float(self.p.step_size_slow)
+        smin0 = wpr0 - 2.0 * float(self.p.step_size_slow)
+        if wpr0 > self._smax1:
+            self._strend = 1
+        if wpr0 < 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
+        fast_line = (
+            fmin0 + float(self.p.step_size_fast)
+            if self._ftrend > 0
+            else fmax0 - float(self.p.step_size_fast)
+        )
+        slow_line = (
+            smin0 + float(self.p.step_size_slow)
+            if self._strend > 0
+            else smax0 - float(self.p.step_size_slow)
+        )
+        self.lines.fast_line[0] = fast_line
+        self.lines.slow_line[0] = slow_line
+        self.lines.wpr_shifted[0] = wpr0
+        self._fmin1 = fmin0
+        self._fmax1 = fmax0
+        self._smin1 = smin0
+        self._smax1 = smax0

backtrader/indicators/contrib/color_schaff_de_marker_trend_cycle.py

@@ -0,0 +1,92 @@
+#!/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 collections import deque
+
+from .. import (
+    DeMarker,
+    Indicator,
+)
+
+__all__ = [
+    "ColorSchaffDeMarkerTrendCycle",
+]
+
+
+class ColorSchaffDeMarkerTrendCycle(Indicator):
+    """Schaff Trend Cycle of DeMarker oscillators with a discrete color line."""
+
+    lines = ("stc", "color")
+    params = (
+        ("fast_demarker", 23),
+        ("slow_demarker", 50),
+        ("cycle", 10),
+        ("high_level", 60),
+        ("low_level", -60),
+    )
+
+    def __init__(self):
+        """Build the fast/slow DeMarkers and initialize the STC smoothing state."""
+        self.addminperiod(
+            3 * max(int(self.p.fast_demarker), int(self.p.slow_demarker)) + int(self.p.cycle) + 5
+        )
+        self.fast_demarker = DeMarker(self.data, period=int(self.p.fast_demarker))
+        self.slow_demarker = DeMarker(self.data, period=int(self.p.slow_demarker))
+        self.factor = 2.0 / (1.0 + float(self.p.cycle))
+        self.macd_window = deque(maxlen=int(self.p.cycle))
+        self.st_window = deque(maxlen=int(self.p.cycle))
+        self.prev_st = None
+        self.prev_stc = None
+
+    def _normalize(self, value, window, scale):
+        if not window:
+            return 0.0
+        llv = min(window)
+        hhv = max(window)
+        if hhv - llv == 0:
+            return None
+        return ((value - llv) / (hhv - llv)) * scale
+
+    def next(self):
+        """Compute the STC value and discrete color code for the current bar."""
+        fast = float(self.fast_demarker[0]) if math.isfinite(float(self.fast_demarker[0])) else 0.0
+        slow = float(self.slow_demarker[0]) if math.isfinite(float(self.slow_demarker[0])) else 0.0
+        macd = fast - slow
+        self.macd_window.append(macd)
+        st_raw = self._normalize(macd, self.macd_window, 100.0)
+        if st_raw is None:
+            st_value = self.prev_st if self.prev_st is not None else 0.0
+        else:
+            st_value = st_raw
+        if self.prev_st is not None:
+            st_value = self.factor * (st_value - self.prev_st) + self.prev_st
+        self.prev_st = st_value
+        self.st_window.append(st_value)
+        stc_raw = self._normalize(st_value, self.st_window, 200.0)
+        if stc_raw is None:
+            stc_value = self.prev_stc if self.prev_stc is not None else 0.0
+        else:
+            stc_value = stc_raw - 100.0
+        if self.prev_stc is not None:
+            stc_value = self.factor * (stc_value - self.prev_stc) + self.prev_stc
+        prev = self.prev_stc if self.prev_stc is not None else stc_value
+        self.prev_stc = stc_value
+        d_sts = stc_value - prev
+        clr = 2
+        if stc_value > 0:
+            if stc_value > float(self.p.high_level):
+                clr = 7 if d_sts >= 0 else 6
+            else:
+                clr = 5 if d_sts >= 0 else 4
+        elif stc_value < 0:
+            if stc_value < float(self.p.low_level):
+                clr = 0 if d_sts < 0 else 1
+            else:
+                clr = 2 if d_sts < 0 else 3
+        self.lines.stc[0] = stc_value
+        self.lines.color[0] = clr

backtrader/indicators/contrib/color_schaff_trend_cycle_indicator.py

@@ -0,0 +1,203 @@
+#!/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,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ColorSchaffTrendCycleIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average selector into a Backtrader indicator class.
+
+    Args:
+        name: MA mode string.
+
+    Returns:
+        class: Backtrader MA indicator class.
+    """
+    mode = str(name).lower()
+    if mode in {"mode_sma", "sma"}:
+        return SimpleMovingAverage
+    if mode in {
+        "mode_ema",
+        "ema",
+        "mode_jjma",
+        "jjma",
+        "mode_jurx",
+        "jurx",
+        "mode_parma",
+        "parma",
+        "mode_t3",
+        "t3",
+        "mode_vidya",
+        "vidya",
+        "mode_ama",
+        "ama",
+    }:
+        return ExponentialMovingAverage
+    if mode in {"mode_smma", "smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Resolve a price series selection for indicator calculations.
+
+    Args:
+        data: Backtrader data feed.
+        mode: Applied price mode string.
+
+    Returns:
+        backtrader line: Selected price series.
+    """
+    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
+    if price_mode in {"price_simpl", "simpl"}:
+        return (data.open + data.close) / 2.0
+    if price_mode in {"price_quarter", "quarter"}:
+        return (data.high + data.low + data.open + data.close) / 4.0
+    return data.close
+
+
+class ColorSchaffTrendCycleIndicator(Indicator):
+    """Custom indicator producing Schaff Trend Cycle value and color states."""
+
+    lines = ("value", "color")
+    params = (
+        ("xma_method", "ema"),
+        ("fast_xma", 23),
+        ("slow_xma", 50),
+        ("xphase", 15),
+        ("applied_price", "price_close"),
+        ("cycle", 10),
+        ("high_level", 60),
+        ("low_level", -60),
+    )
+
+    def __init__(self):
+        """Initialize fast/slow MA dependencies and required history."""
+        price_line = resolve_price_line(self.data, self.p.applied_price)
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        self._fast = ma_cls(price_line, period=max(1, int(self.p.fast_xma)))
+        self._slow = ma_cls(price_line, period=max(1, int(self.p.slow_xma)))
+        self.addminperiod(
+            max(int(self.p.fast_xma), int(self.p.slow_xma)) + int(self.p.cycle) * 2 + 5
+        )
+
+    def next(self):
+        """Advance indicator by one bar and compute `value`/`color` for that bar."""
+        cycle = max(2, int(self.p.cycle))
+        macd_vals = [float(self._fast[-i]) - float(self._slow[-i]) for i in range(cycle)]
+        llv1 = min(macd_vals)
+        hhv1 = max(macd_vals)
+        prev_st = float(self.lines.value[-1]) if len(self) > 0 else 0.0
+        if prev_st != prev_st:
+            prev_st = 0.0
+        cur_macd = macd_vals[0]
+        st = ((cur_macd - llv1) / (hhv1 - llv1) * 100.0) if (hhv1 - llv1) != 0 else prev_st
+        st = 0.5 * (st - prev_st) + prev_st if len(self) > 0 else st
+        st_vals = [st]
+        for i in range(1, cycle):
+            value = float(self.lines.value[-i])
+            if value == value:
+                st_vals.append(value)
+        llv2 = min(st_vals)
+        hhv2 = max(st_vals)
+        prev_stc = float(self.lines.value[-1]) if len(self) > 0 else 0.0
+        if prev_stc != prev_stc:
+            prev_stc = 0.0
+        stc = ((st - llv2) / (hhv2 - llv2) * 200.0 - 100.0) if (hhv2 - llv2) != 0 else prev_stc
+        stc = 0.5 * (stc - prev_stc) + prev_stc if len(self) > 0 else stc
+        self.lines.value[0] = stc
+        delta = stc - prev_stc if len(self) > 0 else 0.0
+        color = 4
+        if stc > 0:
+            if stc > float(self.p.high_level):
+                color = 7 if delta >= 0 else 6
+            else:
+                color = 5 if delta >= 0 else 4
+        if stc < 0:
+            if stc < float(self.p.low_level):
+                color = 0 if delta < 0 else 1
+            else:
+                color = 2 if delta < 0 else 3
+        self.lines.color[0] = color
+
+    def once(self, start, end):
+        """Compute indicator output in vectorized mode for backtest startup."""
+        fast_array = self._fast.array
+        slow_array = self._slow.array
+        value_line = self.lines.value.array
+        color_line = self.lines.color.array
+        for line in (value_line, color_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        cycle = max(2, int(self.p.cycle))
+        prev_value = None
+        actual_end = min(end, len(fast_array), len(slow_array))
+        for i in range(start, actual_end):
+            macd_vals = [
+                float(fast_array[i - j]) - float(slow_array[i - j])
+                for j in range(cycle)
+                if i - j >= 0
+            ]
+            llv1 = min(macd_vals)
+            hhv1 = max(macd_vals)
+            prev_st = 0.0 if prev_value is None else prev_value
+            cur_macd = macd_vals[0]
+            st = ((cur_macd - llv1) / (hhv1 - llv1) * 100.0) if (hhv1 - llv1) != 0 else prev_st
+            if prev_value is not None:
+                st = 0.5 * (st - prev_st) + prev_st
+
+            st_vals = [st]
+            for j in range(1, cycle):
+                idx = i - j
+                if idx < start:
+                    break
+                st_vals.append(float(value_line[idx]))
+            llv2 = min(st_vals)
+            hhv2 = max(st_vals)
+            prev_stc = 0.0 if prev_value is None else prev_value
+            stc = ((st - llv2) / (hhv2 - llv2) * 200.0 - 100.0) if (hhv2 - llv2) != 0 else prev_stc
+            if prev_value is not None:
+                stc = 0.5 * (stc - prev_stc) + prev_stc
+
+            delta = stc - prev_stc if prev_value is not None else 0.0
+            color = 4
+            if stc > 0:
+                if stc > float(self.p.high_level):
+                    color = 7 if delta >= 0 else 6
+                else:
+                    color = 5 if delta >= 0 else 4
+            if stc < 0:
+                if stc < float(self.p.low_level):
+                    color = 0 if delta < 0 else 1
+                else:
+                    color = 2 if delta < 0 else 3
+            value_line[i] = stc
+            color_line[i] = color
+            prev_value = stc