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

backtrader/indicators/contrib/aroon_horn_sign_indicator.py

@@ -0,0 +1,96 @@
+#!/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__ = [
+    "AroonHornSignIndicator",
+]
+
+
+class AroonHornSignIndicator(Indicator):
+    """Reconstructs AroonHornSign indicator.
+
+    BULLS = 100 - (bars_since_highest_high + 0.5) * 100 / AroonPeriod
+    BEARS = 100 - (bars_since_lowest_low + 0.5) * 100 / AroonPeriod
+    trend = +1 if BULLS > BEARS and BULLS >= 50
+    trend = -1 if BULLS < BEARS and BEARS >= 50
+    BullsAroon (buy arrow) when trend flips from -1 to +1: low - ATR*3/8
+    BearsAroon (sell arrow) when trend flips from +1 to -1: high + ATR*3/8
+    Buffers: 0=BearsAroon(sell), 1=BullsAroon(buy).
+    """
+
+    lines = ("bears_aroon", "bulls_aroon")
+    params = (
+        ("aroon_period", 9),
+        ("atr_period", 10),
+    )
+
+    def __init__(self):
+        """Initialize Aroon window, ATR window, and trend tracking state."""
+        self._ap = int(self.p.aroon_period)
+        self._atr_p = int(self.p.atr_period)
+        self._trend_prev = 0
+        self.addminperiod(max(self._ap, self._atr_p) + 3)
+
+    def _calc_atr(self):
+        period = self._atr_p
+        total = 0.0
+        for i in range(period):
+            h = float(self.data.high[-i])
+            low_price = float(self.data.low[-i])
+            if i + 1 < len(self.data):
+                pc = float(self.data.close[-(i + 1)])
+                tr = max(h - low_price, abs(h - pc), abs(low_price - pc))
+            else:
+                tr = h - low_price
+            total += tr
+        return total / period
+
+    def next(self):
+        """Compute bear/bull arrow levels based on trend flips and ATR displacement."""
+        ap = self._ap
+
+        # Find bars since highest high and lowest low within AroonPeriod
+        max_idx = 0
+        max_val = float(self.data.high[0])
+        min_idx = 0
+        min_val = float(self.data.low[0])
+        for i in range(ap):
+            h = float(self.data.high[-i])
+            low_price = float(self.data.low[-i])
+            if h > max_val:
+                max_val = h
+                max_idx = i
+            if low_price < min_val:
+                min_val = low_price
+                min_idx = i
+
+        bulls = 100.0 - (max_idx + 0.5) * 100.0 / ap
+        bears = 100.0 - (min_idx + 0.5) * 100.0 / ap
+
+        trend = self._trend_prev
+        if bulls > bears and bulls >= 50:
+            trend = 1
+        if bulls < bears and bears >= 50:
+            trend = -1
+
+        bu = 0.0
+        be = 0.0
+
+        if self._trend_prev < 0 and trend > 0:
+            atr = self._calc_atr()
+            bu = float(self.data.low[0]) - atr * 3.0 / 8.0
+
+        if self._trend_prev > 0 and trend < 0:
+            atr = self._calc_atr()
+            be = float(self.data.high[0]) + atr * 3.0 / 8.0
+
+        self._trend_prev = trend
+
+        self.lines.bears_aroon[0] = be
+        self.lines.bulls_aroon[0] = bu

backtrader/indicators/contrib/aroon_oscillator_sign_alert.py

@@ -0,0 +1,50 @@
+#!/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__ = [
+    "AroonOscillatorSignAlert",
+]
+
+
+class AroonOscillatorSignAlert(Indicator):
+    """Aroon oscillator alert indicator with buy/sell level trigger lines."""
+
+    lines = ("sell", "buy", "osc")
+    params = (
+        ("atr_period", 14),
+        ("aroon_period", 9),
+        ("up_level", 50),
+        ("dn_level", -50),
+    )
+
+    def __init__(self):
+        """Initialize ATR/Aroon period constraints and ATR helper indicator."""
+        self.addminperiod(max(int(self.p.atr_period), int(self.p.aroon_period)) + 3)
+        self.atr = ATR(self.data, period=int(self.p.atr_period))
+
+    def next(self):
+        """Compute oscillator and emit trigger prices when levels are crossed."""
+        p = int(self.p.aroon_period)
+        highs = [float(self.data.high[-i]) for i in range(p)]
+        lows = [float(self.data.low[-i]) for i in range(p)]
+        highest = highs.index(max(highs))
+        lowest = lows.index(min(lows))
+        osc = 100.0 * (highest - lowest) / float(p)
+        prev = float(self.lines.osc[-1]) if len(self) > 1 else osc
+        self.lines.osc[0] = osc
+        self.lines.buy[0] = float("nan")
+        self.lines.sell[0] = float("nan")
+        atr = float(self.atr[0])
+        if osc > float(self.p.dn_level) and prev <= float(self.p.dn_level):
+            self.lines.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if osc < float(self.p.up_level) and prev >= float(self.p.up_level):
+            self.lines.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0

backtrader/indicators/contrib/arrows_curves_indicator.py

@@ -0,0 +1,112 @@
+#!/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__ = [
+    "ArrowsCurvesIndicator",
+]
+
+
+class ArrowsCurvesIndicator(Indicator):
+    """Custom Arrows and Curves technical indicator.
+
+    Calculates channel boundaries (smax, smin, smax2, smin2) based on highest high and lowest low windows
+    and returns trade entry signals (buy, sell, buy_stop, sell_stop).
+    """
+
+    lines = ("sell", "buy", "sell_stop", "buy_stop", "smax", "smin", "smax2", "smin2")
+    params = (
+        ("ssp", 20),
+        ("channel", 0),
+        ("ch_stop", 30),
+        ("relay", 10),
+    )
+
+    def __init__(self):
+        """Initializes trends, state flags, and sets indicator minimum period requirement."""
+        self.addminperiod(self.p.ssp + self.p.relay + 2)
+        self._uptrend = False
+        self._old = False
+        self._uptrend2 = False
+        self._old2 = False
+
+    def next(self):
+        """Calculates channel lines and signals for each bar.
+
+        Generates buy/sell and buy_stop/sell_stop triggers based on price crossovers
+        and trend state switches.
+        """
+        if len(self.data) <= self.p.ssp + self.p.relay:
+            for line in self.lines:
+                line[0] = 0.0
+            return
+
+        high_window = [
+            float(self.data.high[-shift])
+            for shift in range(self.p.relay, self.p.relay + self.p.ssp)
+        ]
+        low_window = [
+            float(self.data.low[-shift]) for shift in range(self.p.relay, self.p.relay + self.p.ssp)
+        ]
+        close0 = float(self.data.close[0])
+        high_val = max(high_window)
+        low_val = min(low_window)
+        smax = high_val - (low_val - high_val) * self.p.channel / 100.0
+        smin = low_val + (high_val - low_val) * self.p.channel / 100.0
+        smax2 = high_val - (high_val - low_val) * (self.p.channel + self.p.ch_stop) / 100.0
+        smin2 = low_val + (high_val - low_val) * (self.p.channel + self.p.ch_stop) / 100.0
+
+        sell_signal = 0.0
+        buy_signal = 0.0
+        sell_stop = 0.0
+        buy_stop = 0.0
+
+        uptrend = self._uptrend
+        uptrend2 = self._uptrend2
+        old = self._old
+        old2 = self._old2
+
+        if close0 < smin and close0 < smax and uptrend2 is True:
+            uptrend = False
+        if close0 > smax and close0 > smin and uptrend2 is False:
+            uptrend = True
+        if (close0 > smax2 or close0 > smin2) and uptrend is False:
+            uptrend2 = False
+        if (close0 < smin2 or close0 < smax2) and uptrend is True:
+            uptrend2 = True
+
+        if close0 < smin and close0 < smax and uptrend2 is False:
+            sell_signal = low_val
+            uptrend2 = True
+        if close0 > smax and close0 > smin and uptrend2 is True:
+            buy_signal = high_val
+            uptrend2 = False
+
+        if uptrend != old and uptrend is False:
+            sell_signal = low_val
+        if uptrend != old and uptrend is True:
+            buy_signal = high_val
+
+        if uptrend2 != old2 and uptrend2 is True:
+            buy_stop = smax2
+        if uptrend2 != old2 and uptrend2 is False:
+            sell_stop = smin2
+
+        self.lines.sell[0] = sell_signal
+        self.lines.buy[0] = buy_signal
+        self.lines.sell_stop[0] = sell_stop
+        self.lines.buy_stop[0] = buy_stop
+        self.lines.smax[0] = smax
+        self.lines.smin[0] = smin
+        self.lines.smax2[0] = smax2
+        self.lines.smin2[0] = smin2
+
+        self._old = uptrend
+        self._old2 = uptrend2
+        self._uptrend = uptrend
+        self._uptrend2 = uptrend2

backtrader/indicators/contrib/as_ctrend_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__ = [
+    "ASCtrendIndicator",
+]
+
+
+def _wpr(highs, lows, close, period):
+    """Return Williams %R for the last bar given arrays of length >= period."""
+    hh = max(highs[-period:])
+    ll = min(lows[-period:])
+    if hh == ll:
+        return 0.0
+    return -100.0 * (hh - close) / (hh - ll)
+
+
+class ASCtrendIndicator(Indicator):
+    """Reconstructs ASCtrend from its MQ5 source.
+
+    Outputs:
+      - buy_arrow : non-zero price level when a buy arrow fires
+      - sell_arrow: non-zero price level when a sell arrow fires
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (("risk", 4),)
+
+    def __init__(self):
+        """Derive %R thresholds/periods from ``risk`` and reserve warm-up bars."""
+        self._x1 = 67 + int(self.p.risk)
+        self._x2 = 33 - int(self.p.risk)
+        self._wpr_periods = [3, 4, 3 + int(self.p.risk) * 2]
+        self._value10 = 2  # default WPR index
+        min_period = max(3 + int(self.p.risk) * 2, 4) + 1
+        # need enough history for ATR-style range calc (10 bars) + WPR look-back
+        self.addminperiod(max(min_period, 12))
+
+    # -- helpers operating on self.data (signal-timeframe feed) --
+    def _get_wpr_val(self, period_idx, ago):
+        """Compute WPR(period) at bar shifted by -ago from current."""
+        period = self._wpr_periods[period_idx]
+        n = len(self.data)
+        idx = n - 1 - ago
+        if idx < period:
+            return 0.0
+        highs = [float(self.data.high.array[i]) for i in range(idx - period + 1, idx + 1)]
+        lows = [float(self.data.low.array[i]) for i in range(idx - period + 1, idx + 1)]
+        close_val = float(self.data.close.array[idx])
+        return _wpr(highs, lows, close_val, period)
+
+    def next(self):
+        """Emit ASCtrend buy/sell arrows from the %R band transitions per bar."""
+        risk = int(self.p.risk)
+        x1 = self._x1
+        x2 = self._x2
+
+        # --- ATR-style average range (10 bars) ---
+        total_range = 0.0
+        for i in range(1, 11):
+            hi = float(self.data.high[-i])
+            lo = float(self.data.low[-i])
+            prev_close = float(self.data.close[-(i + 1)]) if len(self.data) > i + 1 else lo
+            true_range = max(hi - lo, abs(hi - prev_close), abs(prev_close - lo))
+            total_range += true_range
+        avg_range = total_range / 10.0
+        half_range = avg_range * 0.5
+
+        # --- MRO1 / MRO2: look back for WPR threshold breach ---
+        value10 = self._value10
+        value11 = value10
+
+        # MRO1: check if WPR(3) crossed > x1 recently
+        mro1 = -1
+        for k in range(1, risk * 2 + 1):
+            if len(self.data) <= k:
+                break
+            w = 100.0 - abs(self._get_wpr_val(0, k))  # WPR_Handle[0] period=3
+            if w > x1:
+                mro1 = k
+                break
+
+        # MRO2: check if WPR(4) crossed < x2 recently
+        mro2 = -1
+        for k in range(1, risk * 2 + 1):
+            if len(self.data) <= k:
+                break
+            w = 100.0 - abs(self._get_wpr_val(1, k))  # WPR_Handle[1] period=4
+            if w < x2:
+                mro2 = k
+                break
+
+        if mro1 > -1:
+            value11 = 0
+        else:
+            value11 = value10
+        if mro2 > -1:
+            value11 = 1
+        else:
+            value11 = value10
+
+        # Current WPR value with the selected period
+        wpr_raw = self._get_wpr_val(value11, 0)
+        value2 = 100.0 - abs(wpr_raw)
+
+        buy_val = 0.0
+        sell_val = 0.0
+        cur_high = float(self.data.high[0])
+        cur_low = float(self.data.low[0])
+
+        if value2 < x2:
+            # look back for transition from neutral zone to >x1
+            iii = 1
+            vel = 0.0
+            while len(self.data) > iii:
+                vel = 100.0 - abs(self._get_wpr_val(value11, iii))
+                if x2 <= vel <= x1:
+                    iii += 1
+                else:
+                    break
+            if vel > x1:
+                sell_val = cur_high + half_range
+
+        if value2 > x1:
+            iii = 1
+            vel = 0.0
+            while len(self.data) > iii:
+                vel = 100.0 - abs(self._get_wpr_val(value11, iii))
+                if x2 <= vel <= x1:
+                    iii += 1
+                else:
+                    break
+            if vel < x2:
+                buy_val = cur_low - half_range
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/asimmetric_stoch_nr_indicator.py

@@ -0,0 +1,187 @@
+#!/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__ = [
+    "AsimmetricStochNRIndicator",
+]
+
+
+class AsimmetricStochNRIndicator(Indicator):
+    """Asymmetric stochastic oscillator indicator with dynamic MA smoothing."""
+
+    lines = (
+        "stoch",
+        "signal",
+    )
+    params = (
+        ("kperiod_short", 5),
+        ("kperiod_long", 12),
+        ("dmethod", "sma"),
+        ("dperiod", 7),
+        ("dphase", 15),
+        ("slowing", 3),
+        ("price_field", "lowhigh"),
+        ("sens", 7),
+        ("overbought", 80),
+        ("oversold", 20),
+    )
+
+    def __init__(self):
+        """Initialize period state and minimum bar requirements."""
+        self._kperiod0 = int(self.p.kperiod_short)
+        self._kperiod1 = int(self.p.kperiod_short)
+        self.addminperiod(
+            max(self.p.kperiod_short, self.p.kperiod_long) + self.p.slowing + self.p.dperiod + 5
+        )
+
+    def _stoch_value(self, bar=0):
+        max_value = 0.0
+        min_value = 0.0
+        c_value = 0.0
+        for j in range(bar, bar + int(self.p.slowing)):
+            if str(self.p.price_field).lower() == "closeclose":
+                window_max = max(
+                    float(self.data.close[-idx]) for idx in range(j, j + self._kperiod0)
+                )
+                window_min = min(
+                    float(self.data.close[-idx]) for idx in range(j, j + self._kperiod1)
+                )
+            else:
+                window_max = max(
+                    float(self.data.high[-idx]) for idx in range(j, j + self._kperiod0)
+                )
+                window_min = min(float(self.data.low[-idx]) for idx in range(j, j + self._kperiod1))
+            max_value += window_max
+            min_value += window_min
+            c_value += float(self.data.close[-j])
+        sens_total = float(self.p.sens) * int(self.p.slowing)
+        delta = max_value - min_value
+        diff = sens_total - delta
+        if diff > 0:
+            delta = sens_total
+            min_value -= diff / 2.0
+        if delta:
+            return 100.0 * (c_value - min_value) / delta
+        return -2.0
+
+    def next(self):
+        """Compute current `stoch` and `signal` values using the active periods."""
+        prev_signal = float(self.lines.signal[-1]) if len(self) > 1 else float("nan")
+        self.lines.stoch[0] = self._stoch_value(0)
+        values = [
+            float(self.lines.stoch[-idx])
+            for idx in range(min(len(self), int(self.p.dperiod)) - 1, -1, -1)
+        ]
+        self.lines.signal[0] = self._ma_window_value(values, str(self.p.dmethod), prev_signal)
+        if prev_signal > float(self.p.overbought):
+            self._kperiod0 = int(self.p.kperiod_short)
+            self._kperiod1 = int(self.p.kperiod_long)
+        if prev_signal < float(self.p.oversold):
+            self._kperiod0 = int(self.p.kperiod_long)
+            self._kperiod1 = int(self.p.kperiod_short)
+
+    def _ma_window_value(self, values, method, previous=None):
+        if not values:
+            return float("nan")
+        period = max(1, int(self.p.dperiod))
+        mode = str(method).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", "jjma", "mode_jjma"}:
+            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 _stoch_value_at(self, i, high_array, low_array, close_array, kperiod0, kperiod1):
+        max_value = 0.0
+        min_value = 0.0
+        c_value = 0.0
+        slowing = int(self.p.slowing)
+        if i - slowing + 1 < 0:
+            return float("nan")
+        closeclose = str(self.p.price_field).lower() == "closeclose"
+        for j in range(slowing):
+            bar = i - j
+            if bar - max(kperiod0, kperiod1) + 1 < 0:
+                return float("nan")
+            if closeclose:
+                window_max = max(
+                    float(close_array[idx]) for idx in range(bar - kperiod0 + 1, bar + 1)
+                )
+                window_min = min(
+                    float(close_array[idx]) for idx in range(bar - kperiod1 + 1, bar + 1)
+                )
+            else:
+                window_max = max(
+                    float(high_array[idx]) for idx in range(bar - kperiod0 + 1, bar + 1)
+                )
+                window_min = min(
+                    float(low_array[idx]) for idx in range(bar - kperiod1 + 1, bar + 1)
+                )
+            max_value += window_max
+            min_value += window_min
+            c_value += float(close_array[bar])
+        sens_total = float(self.p.sens) * slowing
+        delta = max_value - min_value
+        diff = sens_total - delta
+        if diff > 0:
+            delta = sens_total
+            min_value -= diff / 2.0
+        if delta:
+            return 100.0 * (c_value - min_value) / delta
+        return -2.0
+
+    def _ma_value_at(self, values, i, previous):
+        period = max(1, int(self.p.dperiod))
+        mode = str(self.p.dmethod).lower()
+        float(values[i])
+        start = max(0, i - period + 1)
+        window = [float(values[idx]) for idx in range(start, i + 1)]
+        return self._ma_window_value(window, mode, previous)
+
+    def once(self, start, end):
+        """Batch compute indicator lines for historical range in one pass."""
+        high_array = self.data.high.array
+        low_array = self.data.low.array
+        close_array = self.data.close.array
+        stoch_line = self.lines.stoch.array
+        signal_line = self.lines.signal.array
+        for line in (stoch_line, signal_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        kperiod0 = int(self.p.kperiod_short)
+        kperiod1 = int(self.p.kperiod_short)
+        previous_signal = None
+        actual_end = min(end, len(high_array), len(low_array), len(close_array))
+        for i in range(start, actual_end):
+            prev_signal_for_state = previous_signal
+            stoch = self._stoch_value_at(i, high_array, low_array, close_array, kperiod0, kperiod1)
+            stoch_line[i] = stoch
+            signal = self._ma_value_at(stoch_line, i, previous_signal)
+            signal_line[i] = signal
+            previous_signal = signal
+            if prev_signal_for_state is not None and prev_signal_for_state > float(
+                self.p.overbought
+            ):
+                kperiod0 = int(self.p.kperiod_short)
+                kperiod1 = int(self.p.kperiod_long)
+            if prev_signal_for_state is not None and prev_signal_for_state < float(self.p.oversold):
+                kperiod0 = int(self.p.kperiod_long)
+                kperiod1 = int(self.p.kperiod_short)
+        self._kperiod0 = kperiod0
+        self._kperiod1 = kperiod1