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

backtrader/indicators/contrib/rkd_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 Indicator
+
+__all__ = [
+    "RKDIndicator",
+]
+
+
+class RKDIndicator(Indicator):
+    """Compute a custom RKD line set from RSV/K/D values."""
+
+    lines = ("rsv", "k", "d")
+    params = (
+        ("kd_period", 30),
+        ("m1", 3),
+        ("m2", 6),
+    )
+
+    def __init__(self):
+        """Define indicator warm-up length before valid line updates."""
+        self.addminperiod(max(int(self.p.kd_period), int(self.p.m1), int(self.p.m2)) + 2)
+
+    def next(self):
+        """Update RSV, K, and D for the latest bar."""
+        kd_period = int(self.p.kd_period)
+        m1 = int(self.p.m1)
+        m2 = int(self.p.m2)
+        highs = [float(self.data.high[-i]) for i in range(kd_period)]
+        lows = [float(self.data.low[-i]) for i in range(kd_period)]
+        max_high = max(highs)
+        min_low = min(lows)
+        denom = max_high - min_low
+        if denom == 0:
+            rsv = 0.0
+        else:
+            rsv = (float(self.data.close[0]) - min_low) / denom * 100.0
+        self.lines.rsv[0] = rsv
+
+        if len(self) < m1:
+            self.lines.k[0] = 0.0
+        else:
+            self.lines.k[0] = sum(float(self.lines.rsv[-i]) for i in range(m1)) / m1
+
+        if len(self) < m2:
+            self.lines.d[0] = 0.0
+        else:
+            self.lines.d[0] = sum(float(self.lines.k[-i]) for i in range(m2)) / m2

backtrader/indicators/contrib/roc2_vg_indicator.py

@@ -0,0 +1,68 @@
+#!/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__ = [
+    "ROC2VGIndicator",
+]
+
+
+def _calc_roc(price, prev_price, roc_type):
+    if prev_price == 0:
+        return 0.0
+    if roc_type == 1:  # MOM
+        return price - prev_price
+    if roc_type == 2:  # ROC
+        return ((price / prev_price) - 1) * 100
+    if roc_type == 3:  # ROCP
+        return (price - prev_price) / prev_price
+    if roc_type == 4:  # ROCR
+        return price / prev_price
+    if roc_type == 5:  # ROCR100
+        return (price / prev_price) * 100
+    return (price - prev_price) / prev_price
+
+
+class ROC2VGIndicator(Indicator):
+    """Reconstructs ROC2_VG indicator.
+
+    DRAW_FILLING between ROC1 and ROC2.
+    Buffer 0 = ROC1 (period1, type1), Buffer 1 = ROC2 (period2, type2).
+    """
+
+    lines = ("roc1", "roc2")
+    params = (
+        ("roc_period1", 8),
+        ("roc_type1", 1),
+        ("roc_period2", 14),
+        ("roc_type2", 1),
+    )
+
+    def __init__(self):
+        """Initialize ROC periods and required minimum history window."""
+        self._p1 = int(self.p.roc_period1)
+        self._p2 = int(self.p.roc_period2)
+        self._t1 = int(self.p.roc_type1)
+        self._t2 = int(self.p.roc_type2)
+        self.addminperiod(max(self._p1, self._p2) + 2)
+
+    def next(self):
+        """Populate ``roc1`` and ``roc2`` for the current bar."""
+        price = float(self.data.close[0])
+
+        if self._p1 < len(self.data):
+            prev1 = float(self.data.close[-self._p1])
+        else:
+            prev1 = price
+        self.lines.roc1[0] = _calc_roc(price, prev1, self._t1)
+
+        if self._p2 < len(self.data):
+            prev2 = float(self.data.close[-self._p2])
+        else:
+            prev2 = price
+        self.lines.roc2[0] = _calc_roc(price, prev2, self._t2)

backtrader/indicators/contrib/rsi_histogram_indicator.py

@@ -0,0 +1,43 @@
+#!/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 (
+    RSI,
+    Indicator,
+)
+
+__all__ = [
+    "RSIHistogramIndicator",
+]
+
+
+class RSIHistogramIndicator(Indicator):
+    """Compute RSI values and convert to a three-state color histogram."""
+
+    lines = ("value", "midline", "color_state")
+    params = (
+        ("rsi_period", 14),
+        ("high_level", 60),
+        ("low_level", 40),
+    )
+
+    def __init__(self):
+        """Initialize RSI and minimum period."""
+        self.rsi = RSI(self.data.close, period=self.p.rsi_period, safediv=True)
+        self.addminperiod(self.p.rsi_period + 1)
+
+    def next(self):
+        """Update value, midline, and current color state."""
+        rsi_value = float(self.rsi[0])
+        color = 1.0
+        if rsi_value > float(self.p.high_level):
+            color = 0.0
+        elif rsi_value < float(self.p.low_level):
+            color = 2.0
+        self.lines.value[0] = rsi_value
+        self.lines.midline[0] = 50.0
+        self.lines.color_state[0] = color

backtrader/indicators/contrib/rsi_slowdown.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 (
+    ATR,
+    RSI,
+    Indicator,
+)
+
+__all__ = [
+    "RSISlowdown",
+]
+
+
+class RSISlowdown(Indicator):
+    """RSI Slowdown — detects RSI extreme flattening as reversal signal.
+
+    Fires buy when RSI(2) >= level_max (overbought) and the change between
+    consecutive bars is small (slowdown). Fires sell symmetrically at
+    level_min (oversold). Signal lines store ATR-scaled price levels.
+    """
+
+    lines = ("sell", "buy")
+    params = (
+        ("rsi_period", 2),
+        ("level_max", 90.0),
+        ("level_min", 10.0),
+        ("seek_slowdown", True),
+    )
+
+    def __init__(self):
+        """Create RSI and ATR indicators and set minimum required periods."""
+        self.addminperiod(max(int(self.p.rsi_period) + 2, 18))
+        self.rsi = RSI(self.data, period=int(self.p.rsi_period))
+        self.atr = ATR(self.data, period=15)
+
+    def next(self):
+        """Compute RSI slowdown signal for the current bar.
+
+        Sets buy/sell lines to ATR-derived price levels when the RSI extreme
+        + slowdown condition is met, or NaN otherwise.
+        """
+        self.lines.buy[0] = float("nan")
+        self.lines.sell[0] = float("nan")
+        r0 = float(self.rsi[0])
+        r1 = float(self.rsi[-1])
+        atr = float(self.atr[0])
+        if r0 >= float(self.p.level_max):
+            if (not self.p.seek_slowdown) or abs(r1 - r0) < 1.0:
+                self.lines.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if r0 <= float(self.p.level_min):
+            if (not self.p.seek_slowdown) or abs(r1 - r0) < 1.0:
+                self.lines.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0

backtrader/indicators/contrib/rsioma_v2.py

@@ -0,0 +1,41 @@
+#!/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,
+    RSI,
+    Indicator,
+    Momentum,
+)
+
+__all__ = [
+    "RsiomaV2",
+]
+
+
+class RsiomaV2(Indicator):
+    """RSIOMA V2 indicator: an RSI of smoothed price with an EMA signal line.
+
+    The price close is smoothed with an EMA (optionally transformed by a
+    Momentum step), an RSI is computed on that series to form the rsioma line,
+    and the rsioma is smoothed again with an EMA to form the signal line.
+    """
+
+    lines = ("rsioma", "signal")
+    params = (
+        ("rsioma_period", 14),
+        ("ma_rsioma_period", 21),
+        ("mom_period", 1),
+    )
+
+    def __init__(self):
+        """Build the EMA/Momentum/RSI/EMA chain for the rsioma and signal lines."""
+        base = EMA(self.data.close, period=max(int(self.p.rsioma_period), 1))
+        if int(self.p.mom_period) > 1:
+            base = Momentum(base, period=int(self.p.mom_period))
+        self.l.rsioma = RSI(base, period=max(int(self.p.rsioma_period), 1), safediv=True)
+        self.l.signal = EMA(self.l.rsioma, period=max(int(self.p.ma_rsioma_period), 1))

backtrader/indicators/contrib/rvi_histogram_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.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "RVIHistogramIndicator",
+]
+
+
+class _RollingWeightedAverage4:
+    """Symmetric 4-bar weighted average (weights 1-2-2-1) over a rolling window."""
+
+    def __init__(self):
+        """Initialize the rolling value buffer."""
+        self.values = []
+
+    def update(self, value):
+        """Add a value and return the 4-bar weighted average.
+
+        Args:
+            value: The new value to incorporate.
+
+        Returns:
+            The weighted average once four values are buffered, else 0.0.
+        """
+        self.values.append(float(value))
+        if len(self.values) > 4:
+            self.values.pop(0)
+        if len(self.values) < 4:
+            return 0.0
+        return (self.values[3] + 2.0 * self.values[2] + 2.0 * self.values[1] + self.values[0]) / 6.0
+
+
+class _RollingSimpleAverage:
+    """Simple moving average over a fixed-length rolling window."""
+
+    def __init__(self, period):
+        """Initialize the rolling buffer.
+
+        Args:
+            period: Window length (clamped to at least 1).
+        """
+        self.period = max(int(period), 1)
+        self.values = []
+
+    def update(self, value):
+        """Add a value and return the current simple moving average.
+
+        Args:
+            value: The new value to incorporate.
+
+        Returns:
+            The simple moving average of the buffered values.
+        """
+        self.values.append(float(value))
+        if len(self.values) > self.period:
+            self.values.pop(0)
+        if not self.values:
+            return 0.0
+        return sum(self.values) / len(self.values)
+
+
+class RVIHistogramIndicator(Indicator):
+    """Relative Vigor Index with a smoothed signal line and color state."""
+
+    lines = ("main", "signal", "hist_base", "color_state")
+    params = (
+        ("rvi_period", 14),
+        ("high_level", 0.3),
+        ("low_level", -0.3),
+    )
+
+    def __init__(self):
+        """Build the weighted/simple averagers used by the RVI computation."""
+        self._co_avg4 = _RollingWeightedAverage4()
+        self._hl_avg4 = _RollingWeightedAverage4()
+        self._num_sma = _RollingSimpleAverage(self.p.rvi_period)
+        self._den_sma = _RollingSimpleAverage(self.p.rvi_period)
+        self._main_avg4 = _RollingWeightedAverage4()
+        self.addminperiod(int(self.p.rvi_period) + 6)
+
+    def next(self):
+        """Compute the RVI main/signal lines and the level-based color state."""
+        co = float(self.data.close[0]) - float(self.data.open[0])
+        hl = float(self.data.high[0]) - float(self.data.low[0])
+        weighted_co = self._co_avg4.update(co)
+        weighted_hl = self._hl_avg4.update(hl)
+        num = self._num_sma.update(weighted_co)
+        den = self._den_sma.update(weighted_hl)
+        main = num / den if abs(den) > 1e-12 else 0.0
+        signal = self._main_avg4.update(main)
+
+        color = 1.0
+        if main > float(self.p.high_level):
+            color = 0.0
+        elif main < float(self.p.low_level):
+            color = 2.0
+
+        self.lines.main[0] = main
+        self.lines.signal[0] = signal
+        self.lines.hist_base[0] = 0.0
+        self.lines.color_state[0] = color

backtrader/indicators/contrib/safe_adx.py

@@ -0,0 +1,89 @@
+#!/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__ = [
+    "SafeADX",
+    "SafeAMA",
+]
+
+
+class SafeADX(Indicator):
+    """ADX indicator implementation without division by zero pitfalls."""
+
+    lines = ("adx",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Set minimum lookback period."""
+        self.addminperiod(self.p.period + 3)
+
+    def next(self):
+        """Compute safe directional movement and ADX-like intensity."""
+        pdm_vals = []
+        mdm_vals = []
+        tr_vals = []
+        for idx in range(self.p.period):
+            high0 = float(self.data.high[-idx])
+            high1 = float(self.data.high[-idx - 1])
+            low0 = float(self.data.low[-idx])
+            low1 = float(self.data.low[-idx - 1])
+            close1 = float(self.data.close[-idx - 1])
+            up_move = high0 - high1
+            down_move = low1 - low0
+            pdm = up_move if up_move > down_move and up_move > 0 else 0.0
+            mdm = down_move if down_move > up_move and down_move > 0 else 0.0
+            tr = max(high0 - low0, abs(high0 - close1), abs(low0 - close1))
+            pdm_vals.append(pdm)
+            mdm_vals.append(mdm)
+            tr_vals.append(tr)
+        tr_sum = sum(tr_vals)
+        if tr_sum <= 1e-12:
+            self.lines.adx[0] = 0.0
+            return
+        pdi = 100.0 * sum(pdm_vals) / tr_sum
+        mdi = 100.0 * sum(mdm_vals) / tr_sum
+        denom = pdi + mdi
+        if denom <= 1e-12:
+            self.lines.adx[0] = 0.0
+            return
+        self.lines.adx[0] = 100.0 * abs(pdi - mdi) / denom
+
+
+class SafeAMA(Indicator):
+    """Adaptive moving average indicator with safe initialization."""
+
+    lines = ("ama",)
+    params = (
+        ("period", 9),
+        ("fast_period", 2),
+        ("slow_period", 30),
+    )
+
+    def __init__(self):
+        """Initialize adaptive moving average state and warm-up window."""
+        self._prev = None
+        self.addminperiod(self.p.period + 3)
+
+    def next(self):
+        """Update AMA based on efficiency ratio and smoothing."""
+        if len(self) == 0 or self._prev is None:
+            self._prev = float(self.data.close[0])
+            self.lines.ama[0] = self._prev
+            return
+        direction = abs(float(self.data.close[0]) - float(self.data.close[-self.p.period]))
+        volatility = 0.0
+        for idx in range(self.p.period):
+            volatility += abs(float(self.data.close[-idx]) - float(self.data.close[-idx - 1]))
+        efficiency = 0.0 if volatility <= 1e-12 else direction / volatility
+        fast_sc = 2.0 / (self.p.fast_period + 1.0)
+        slow_sc = 2.0 / (self.p.slow_period + 1.0)
+        smoothing = (efficiency * (fast_sc - slow_sc) + slow_sc) ** 2
+        current = self._prev + smoothing * (float(self.data.close[0]) - self._prev)
+        self.lines.ama[0] = current
+        self._prev = current