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

backtrader/indicators/contrib/step_manrtr_indicator.py

@@ -0,0 +1,137 @@
+#!/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__ = [
+    "StepMANRTRIndicator",
+]
+
+
+class StepMANRTRIndicator(Indicator):
+    """Reconstructs StepMA_NRTR indicator.
+
+    StepSizeCalc: Volty-based step size from ATR-like calculation.
+    StepMACalc: Trend-following MA with NRTR ratchet.
+    4 buffers: UpBuffer(0), DnBuffer(1), BuySignal(2), SellSignal(3).
+    Buy when trend flips from down to up. Sell on reverse.
+    """
+
+    lines = ("trend_up", "trend_down", "buy_signal", "sell_signal")
+    params = (
+        ("length", 10),
+        ("kv", 1.0),
+        ("step_size", 0),
+        ("percentage", 0),
+        ("switch", 1),
+    )
+
+    def __init__(self):
+        """Initialize rolling state and derived parameters for indicator updates."""
+        self._length = int(self.p.length)
+        self._kv = float(self.p.kv)
+        self._step_size = int(self.p.step_size)
+        self._percentage = float(self.p.percentage)
+        self._switch = int(self.p.switch)  # 0=Close, 1=HighLow
+        self._trend0 = 0
+        self._trend1 = 0
+        self._trend1_ = 0
+        self._smax1 = 0.0
+        self._smin1 = 0.0
+        self._first = True
+        self.addminperiod(self._length + 3)
+
+    def _step_size_calc(self, bar_idx):
+        length = self._length
+        kv = self._kv
+        if self._step_size > 0:
+            return self._step_size
+        # Volty calculation: average of high-low ranges
+        total = 0.0
+        for i in range(length):
+            h = float(self.data.high[-i])
+            low_price = float(self.data.low[-i])
+            total += h - low_price
+        avg = total / length if length > 0 else 0
+        # Convert to points-like value
+        step = avg * kv / self.data.close[0] * 10000 if self.data.close[0] != 0 else 0
+        return max(step, 1)
+
+    def _step_ma_calc(self):
+        step = self._step_size_calc(0)
+        point = float(self.data.close[0]) / 10000.0 if float(self.data.close[0]) > 10 else 0.0001
+        size_p = step * point
+        size_2p = size_p * 2
+
+        cur_high = float(self.data.high[0])
+        cur_low = float(self.data.low[0])
+        cur_close = float(self.data.close[0])
+
+        if self._first:
+            self._trend1 = 0
+            self._smax1 = cur_low + size_2p
+            self._smin1 = cur_high - size_2p
+            self._first = False
+
+        if self._switch:  # HighLow mode
+            smax0 = cur_high - size_2p
+            smin0 = cur_low + size_2p
+        else:
+            smax0 = cur_close + size_2p
+            smin0 = cur_close - size_2p
+
+        self._trend0 = self._trend1
+
+        if cur_close > self._smax1:
+            self._trend0 = 1
+        if cur_close < self._smin1:
+            self._trend0 = -1
+
+        if self._trend0 > 0:
+            if smin0 < self._smin1:
+                smin0 = self._smin1
+            result = smin0 + size_p
+        else:
+            if smax0 > self._smax1:
+                smax0 = self._smax1
+            result = smax0 - size_p
+
+        self._trend1_ = self._trend1
+        self._smax1 = smax0
+        self._smin1 = smin0
+        self._trend1 = self._trend0
+
+        return result, size_p
+
+    def next(self):
+        """Compute trend-up/down lines and buy/sell trigger levels for this bar."""
+        result, size_p = self._step_ma_calc()
+        ratio = self._percentage / 100.0 if self._percentage > 0 else 0
+        step = self._step_size_calc(0)
+        if step > 0:
+            result += ratio / step
+
+        tu = 0.0
+        td = 0.0
+        bs = 0.0
+        ss = 0.0
+
+        point = float(self.data.close[0]) / 10000.0 if float(self.data.close[0]) > 10 else 0.0001
+
+        if self._trend0 > 0:
+            tu = result - step * point
+            if self._trend1_ < 0:
+                bs = tu
+        if self._trend0 < 0:
+            td = result + step * point
+            if self._trend1_ > 0:
+                ss = td
+
+        self.lines.trend_up[0] = tu
+        self.lines.trend_down[0] = td
+        self.lines.buy_signal[0] = bs
+        self.lines.sell_signal[0] = ss

backtrader/indicators/contrib/stochastic_histogram_indicator.py

@@ -0,0 +1,143 @@
+#!/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__ = [
+    "StochasticHistogramIndicator",
+]
+
+
+class StochasticHistogramIndicator(Indicator):
+    """Stochastic-based indicator with a smoothed main line, signal line, and color state.
+
+    The indicator outputs:
+    - ``main``: smoothed %K values.
+    - ``signal``: smoothed trigger line derived from main.
+    - ``hist_base``: fixed base reference line (50.0).
+    - ``color_state``: 0 for overbought, 1 for neutral, 2 for oversold.
+    """
+
+    lines = ("main", "signal", "hist_base", "color_state")
+    params = (
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+        ("ma_method", "sma"),
+        ("high_level", 60),
+        ("low_level", 40),
+    )
+
+    def __init__(self):
+        """Set the minimum required bars from K, slowing, and D periods."""
+        self.addminperiod(int(self.p.k_period) + int(self.p.slowing) + int(self.p.d_period) + 2)
+
+    def _fast_k_at(self, i, high_array, low_array, close_array):
+        period = max(1, int(self.p.k_period))
+        if i - period + 1 < 0:
+            return float("nan")
+        lowest = min(float(low_array[idx]) for idx in range(i - period + 1, i + 1))
+        highest = max(float(high_array[idx]) for idx in range(i - period + 1, i + 1))
+        denom = highest - lowest
+        return 100.0 * (float(close_array[i]) - lowest) / denom if denom else 50.0
+
+    def _ma_value(self, values, period, previous=None):
+        if not values:
+            return float("nan")
+        mode = str(self.p.ma_method).strip().lower()
+        value = float(values[-1])
+        if mode in {"ema", "mode_ema"}:
+            if previous is None or previous != previous:
+                return value
+            alpha = 2.0 / (period + 1.0)
+            return previous + alpha * (value - previous)
+        if mode in {"smma", "mode_smma"}:
+            if previous is None or previous != previous:
+                return value
+            return ((period - 1.0) * previous + value) / period
+        if mode in {"lwma", "wma", "mode_lwma"}:
+            weights = list(range(1, len(values) + 1))
+            return sum(v * w for v, w in zip(values, weights)) / sum(weights)
+        return sum(values) / len(values)
+
+    def next(self):
+        """Compute indicator values for one new bar in Backtrader streaming mode."""
+        k_period = max(1, int(self.p.k_period))
+        slowing = max(1, int(self.p.slowing))
+        d_period = max(1, int(self.p.d_period))
+        fast_values = []
+        for ago in range(slowing - 1, -1, -1):
+            if len(self.data) <= ago + k_period - 1:
+                return
+            low_values = [float(self.data.low[-ago - shift]) for shift in range(k_period)]
+            high_values = [float(self.data.high[-ago - shift]) for shift in range(k_period)]
+            lowest = min(low_values)
+            highest = max(high_values)
+            denom = highest - lowest
+            fast_values.append(
+                100.0 * (float(self.data.close[-ago]) - lowest) / denom if denom else 50.0
+            )
+        prev_main = float(self.lines.main[-1]) if len(self) > 1 else None
+        prev_signal = float(self.lines.signal[-1]) if len(self) > 1 else None
+        main = self._ma_value(fast_values, slowing, prev_main)
+        self.lines.main[0] = main
+        signal_values = [
+            float(self.lines.main[-ago]) for ago in range(min(len(self), d_period) - 1, 0, -1)
+        ]
+        signal_values.append(main)
+        self.lines.signal[0] = self._ma_value(signal_values, d_period, prev_signal)
+        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.color_state[0] = color
+        self.lines.hist_base[0] = 50.0
+
+    def once(self, start, end):
+        """Compute indicator arrays for run-once mode from ``start`` to ``end`` indices."""
+        high_array = self.data.high.array
+        low_array = self.data.low.array
+        close_array = self.data.close.array
+        main_line = self.lines.main.array
+        signal_line = self.lines.signal.array
+        hist_base_line = self.lines.hist_base.array
+        color_state_line = self.lines.color_state.array
+        for line in (main_line, signal_line, hist_base_line, color_state_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        slowing = max(1, int(self.p.slowing))
+        d_period = max(1, int(self.p.d_period))
+        actual_end = min(end, len(high_array), len(low_array), len(close_array))
+        fast_values = [
+            self._fast_k_at(i, high_array, low_array, close_array) for i in range(actual_end)
+        ]
+        main_values = []
+        signal_values_all = []
+        prev_main = None
+        prev_signal = None
+        for i in range(actual_end):
+            main_start = max(0, i - slowing + 1)
+            main = self._ma_value(fast_values[main_start : i + 1], slowing, prev_main)
+            main_values.append(main)
+            prev_main = main
+            signal_start = max(0, i - d_period + 1)
+            signal = self._ma_value(main_values[signal_start : i + 1], d_period, prev_signal)
+            signal_values_all.append(signal)
+            prev_signal = signal
+            if i < start:
+                continue
+            main_line[i] = main
+            signal_line[i] = signal_values_all[i]
+            color = 1.0
+            if main > float(self.p.high_level):
+                color = 0.0
+            elif main < float(self.p.low_level):
+                color = 2.0
+            color_state_line[i] = color
+            hist_base_line[i] = 50.0

backtrader/indicators/contrib/t3_alarm_indicator.py

@@ -0,0 +1,125 @@
+#!/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__ = [
+    "T3AlarmIndicator",
+]
+
+
+class T3AlarmIndicator(Indicator):
+    """Double-smoothed MA slope indicator emitting direction and reversal alarms."""
+
+    lines = ("ma2", "direction", "buy_sig", "sell_sig")
+    params = (
+        ("ma_period", 19),
+        ("ma_shift", 0),
+        ("ma_method", "ema"),
+        ("ma_price", "close"),
+    )
+
+    def __init__(self):
+        """Build the twice-applied moving average and reset the prior direction."""
+        price = self._price_line(self.p.ma_price)
+        ma_cls = self._ma_class(self.p.ma_method)
+        ma1 = ma_cls(price, period=self.p.ma_period)
+        self.lines.ma2 = ma_cls(ma1, period=self.p.ma_period)
+        self._ma_shift = int(self.p.ma_shift)
+        self._prev_direction = 0
+
+    def next(self):
+        """Update the direction line and raise buy/sell alarms on slope flips."""
+        shift = self._ma_shift
+        ma2_curr = self.lines.ma2[-shift] if shift > 0 else self.lines.ma2[0]
+        ma2_prev = self.lines.ma2[-(shift + 1)] if True else self.lines.ma2[-1]
+
+        if ma2_curr > ma2_prev:
+            direction = 1
+        elif ma2_curr < ma2_prev:
+            direction = -1
+        else:
+            direction = self._prev_direction
+
+        prev_dir = self._prev_direction
+        self._prev_direction = direction
+        self.lines.direction[0] = float(direction)
+        self.lines.buy_sig[0] = 1.0 if (direction == 1 and prev_dir == -1) else 0.0
+        self.lines.sell_sig[0] = 1.0 if (direction == -1 and prev_dir == 1) else 0.0
+
+    def once(self, start, end):
+        """Vectorised batch evaluation of direction and alarm lines.
+
+        Args:
+            start: Inclusive start index of the range to fill.
+            end: Exclusive end index of the range to fill.
+        """
+        ma2 = self.lines.ma2.array
+        direction_line = self.lines.direction.array
+        buy_line = self.lines.buy_sig.array
+        sell_line = self.lines.sell_sig.array
+        for line in (direction_line, buy_line, sell_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        shift = self._ma_shift
+        prev_direction = 0
+        actual_end = min(end, len(ma2))
+        for i in range(start, actual_end):
+            curr_idx = i - shift if shift > 0 else i
+            prev_idx = i - shift - 1
+            if curr_idx < 0 or prev_idx < 0:
+                direction = prev_direction
+            else:
+                ma2_curr = ma2[curr_idx]
+                ma2_prev = ma2[prev_idx]
+                if ma2_curr > ma2_prev:
+                    direction = 1
+                elif ma2_curr < ma2_prev:
+                    direction = -1
+                else:
+                    direction = prev_direction
+
+            prev_dir = prev_direction
+            prev_direction = direction
+            direction_line[i] = float(direction)
+            buy_line[i] = 1.0 if (direction == 1 and prev_dir == -1) else 0.0
+            sell_line[i] = 1.0 if (direction == -1 and prev_dir == 1) else 0.0
+        self._prev_direction = prev_direction
+
+    def _ma_class(self, method):
+        name = str(method).lower()
+        mapping = {
+            "sma": SimpleMovingAverage,
+            "ema": ExponentialMovingAverage,
+            "smma": SmoothedMovingAverage,
+            "lwma": WeightedMovingAverage,
+            "wma": WeightedMovingAverage,
+        }
+        return mapping.get(name, ExponentialMovingAverage)
+
+    def _price_line(self, price_name):
+        name = str(price_name).lower()
+        if name == "open":
+            return self.data.open
+        if name == "high":
+            return self.data.high
+        if name == "low":
+            return self.data.low
+        if name == "median":
+            return (self.data.high + self.data.low) / 2.0
+        if name == "typical":
+            return (self.data.high + self.data.low + self.data.close) / 3.0
+        if name == "weighted":
+            return (self.data.high + self.data.low + self.data.close + self.data.close) / 4.0
+        return self.data.close

backtrader/indicators/contrib/t3_average.py

@@ -0,0 +1,76 @@
+#!/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 backtrader.functions as btfunc
+
+from .. import (
+    EMA,
+    Indicator,
+)
+
+__all__ = [
+    "T3Average",
+    "T3Trix",
+]
+
+
+class T3Average(Indicator):
+    """Tillson T3 moving average built from a six-stage EMA cascade."""
+
+    lines = ("t3",)
+    params = (
+        ("period", 10),
+        ("vfactor", 0.7),
+    )
+
+    def __init__(self):
+        """Build the six EMA stages and combine them into the T3 line.
+
+        Side effects:
+            Creates the cascade of six EMAs and assigns ``t3`` as the
+            volume-factor-weighted combination of the third through sixth stages.
+        """
+        period = max(int(self.p.period), 1)
+        vfactor = min(max(float(self.p.vfactor), 0.0), 1.0)
+        e1 = EMA(self.data, period=period)
+        e2 = EMA(e1, period=period)
+        e3 = EMA(e2, period=period)
+        e4 = EMA(e3, period=period)
+        e5 = EMA(e4, period=period)
+        e6 = EMA(e5, period=period)
+
+        c1 = -(vfactor**3)
+        c2 = 3 * vfactor**2 + 3 * vfactor**3
+        c3 = -6 * vfactor**2 - 3 * vfactor - 3 * vfactor**3
+        c4 = 1 + 3 * vfactor + vfactor**3 + 3 * vfactor**2
+        self.l.t3 = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3
+
+
+class T3Trix(Indicator):
+    """TRIX-style oscillator built from fast and slow T3 rate-of-change lines."""
+
+    lines = ("fast", "slow", "hist")
+    params = (
+        ("xlength1", 10),
+        ("xlength2", 18),
+        ("xphase", 70),
+    )
+
+    def __init__(self):
+        """Build fast/slow T3 averages and their normalized rate-of-change lines.
+
+        Side effects:
+            Derives the volume factor from ``xphase``, builds the fast and slow
+            ``T3Average`` lines, and assigns ``fast``/``slow`` as their per-bar
+            relative changes with ``hist`` aliased to ``fast``.
+        """
+        vfactor = min(max(float(self.p.xphase) / 100.0, 0.0), 1.0)
+        fast_t3 = T3Average(self.data.close, period=int(self.p.xlength1), vfactor=vfactor)
+        slow_t3 = T3Average(self.data.close, period=int(self.p.xlength2), vfactor=vfactor)
+        self.l.fast = btfunc.DivByZero(fast_t3 - fast_t3(-1), fast_t3(-1), zero=0.0)
+        self.l.slow = btfunc.DivByZero(slow_t3 - slow_t3(-1), slow_t3(-1), zero=0.0)
+        self.l.hist = self.l.fast

backtrader/indicators/contrib/t3_indicator.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 (
+    EMA,
+    Indicator,
+)
+
+__all__ = [
+    "T3Indicator",
+]
+
+
+class T3Indicator(Indicator):
+    """Tillson T3 moving average — six cascaded EMAs with volume factor."""
+
+    lines = ("t3",)
+    params = (
+        ("period", 4),
+        ("vfactor", 0.7),
+    )
+
+    def __init__(self):
+        """Build the six cascaded EMAs and the T3 weighted combination line."""
+        e1 = EMA(self.data, period=self.p.period)
+        e2 = EMA(e1, period=self.p.period)
+        e3 = EMA(e2, period=self.p.period)
+        e4 = EMA(e3, period=self.p.period)
+        e5 = EMA(e4, period=self.p.period)
+        e6 = EMA(e5, period=self.p.period)
+        v = self.p.vfactor
+        c1 = -(v * v * v)
+        c2 = 3 * v * v + 3 * v * v * v
+        c3 = -6 * v * v - 3 * v - 3 * v * v * v
+        c4 = 1 + 3 * v + v * v * v + 3 * v * v
+        self.lines.t3 = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3

backtrader/indicators/contrib/the20s_v020_signal.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 (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "The20sV020Signal",
+]
+
+
+class The20sV020Signal(Indicator):
+    """Reversal signal from prior-bar 20% zones with an ATR-offset entry."""
+
+    lines = ("sell", "buy")
+    params = (
+        ("alg", "MODE_1"),
+        ("level", 100),
+        ("ratio", 0.2),
+        ("direct", False),
+        ("atr_period", 15),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Build the ATR sub-indicator and set the warm-up minimum period."""
+        self.atr = ATR(self.data, period=max(int(self.p.atr_period), 1))
+        self.addminperiod(max(int(self.p.atr_period), 5) + 6)
+
+    def next(self):
+        """Emit buy/sell signal levels from the prior-bar 20% zone logic.
+
+        Resets both lines to zero, and once enough bars exist computes the
+        prior-bar range, its upper/lower 20% zones, and the ATR. Under MODE_1 it
+        flags a reversal when the previous bar spans the band and the current bar
+        breaks beyond it by the level threshold; under MODE_2 it uses a three-bar
+        expansion-then-inside pattern. The ``direct`` flag optionally swaps the
+        buy and sell outputs.
+        """
+        self.lines.buy[0] = 0.0
+        self.lines.sell[0] = 0.0
+
+        if len(self.data) < 6:
+            return
+
+        dlevel = float(self.p.level) * float(self.p.point)
+        last_range = float(self.data.high[-1]) - float(self.data.low[-1])
+        top20 = float(self.data.high[-1]) - last_range * float(self.p.ratio)
+        bottom20 = float(self.data.low[-1]) + last_range * float(self.p.ratio)
+        atr = float(self.atr[0])
+
+        raw_buy = 0.0
+        raw_sell = 0.0
+
+        if str(self.p.alg) == "MODE_1":
+            if (
+                float(self.data.open[-1]) >= top20
+                and float(self.data.close[-1]) <= bottom20
+                and float(self.data.low[0]) <= float(self.data.low[-1]) - dlevel
+            ):
+                raw_buy = float(self.data.low[0]) - atr * 3.0 / 8.0
+            elif (
+                float(self.data.open[-1]) <= bottom20
+                and float(self.data.close[-1]) >= top20
+                and float(self.data.high[0]) >= float(self.data.high[-1]) + dlevel
+            ):
+                raw_sell = float(self.data.high[0]) + atr * 3.0 / 8.0
+        else:
+            cond = (
+                (float(self.data.high[-4]) - float(self.data.low[-4]) > last_range)
+                and (float(self.data.high[-3]) - float(self.data.low[-3]) > last_range)
+                and (float(self.data.high[-2]) - float(self.data.low[-2]) > last_range)
+                and float(self.data.high[-2]) > float(self.data.high[-1])
+                and float(self.data.low[-2]) < float(self.data.low[-1])
+            )
+            if cond:
+                if float(self.data.open[0]) <= bottom20:
+                    raw_buy = float(self.data.low[0]) - atr * 3.0 / 8.0
+                if float(self.data.open[0]) >= top20:
+                    raw_sell = float(self.data.high[0]) + atr * 3.0 / 8.0
+
+        if bool(self.p.direct):
+            self.lines.buy[0] = raw_buy
+            self.lines.sell[0] = raw_sell
+        else:
+            self.lines.buy[0] = raw_sell
+            self.lines.sell[0] = raw_buy

backtrader/indicators/contrib/three_candles_indicator.py

@@ -0,0 +1,70 @@
+#!/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__ = [
+    "ThreeCandlesIndicator",
+]
+
+
+class ThreeCandlesIndicator(Indicator):
+    """Indicator producing three-candle reversal signal labels."""
+
+    lines = ("signal",)
+    params = (
+        ("max_bar1", 300),
+        ("volume_type", "tick"),
+    )
+
+    def __init__(self):
+        """Require enough history before the indicator can emit stable signals."""
+        self.addminperiod(5)
+
+    def next(self):
+        """Evaluate bullish/bearish setups and emit normalized signal codes."""
+        self.lines.signal[0] = 2.0
+
+        chk_vol = True
+        range_points = float(self.data.high[-3] - self.data.low[-3])
+        point = float(getattr(self.data, "_point_value", 0.01) or 0.01)
+        if point > 0 and range_points / point > float(self.p.max_bar1):
+            chk_vol = False
+
+        bullish_setup = (
+            float(self.data.open[-3]) < float(self.data.close[-3])
+            and float(self.data.open[-2]) < float(self.data.close[-2])
+            and float(self.data.close[-2]) < float(self.data.high[-3])
+            and float(self.data.open[-1]) > float(self.data.close[-1])
+            and float(self.data.close[-1]) < float(self.data.open[-2])
+        )
+        bearish_setup = (
+            float(self.data.open[-3]) > float(self.data.close[-3])
+            and float(self.data.open[-2]) > float(self.data.close[-2])
+            and float(self.data.close[-2]) > float(self.data.low[-3])
+            and float(self.data.open[-1]) < float(self.data.close[-1])
+            and float(self.data.close[-1]) > float(self.data.open[-2])
+        )
+
+        vol_series = self.data.volume
+
+        def volume_filter_ok():
+            if not chk_vol or self.p.volume_type == "none":
+                return True
+            v3 = float(vol_series[-3])
+            v2 = float(vol_series[-2])
+            v1 = float(vol_series[-1])
+            return v3 < v2 or v1 > v2 or v1 > v3
+
+        if bullish_setup and volume_filter_ok():
+            self.lines.signal[0] = (
+                0.0 if float(self.data.close[0]) < float(self.data.open[0]) else 1.0
+            )
+        if bearish_setup and volume_filter_ok():
+            self.lines.signal[0] = (
+                3.0 if float(self.data.close[0]) < float(self.data.open[0]) else 4.0
+            )