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

backtrader/indicators/contrib/blau_ts_stochastic.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.
+"""
+
+import backtrader.functions as btfunc
+
+from .. import (
+    EMA,
+    Highest,
+    Indicator,
+    Lowest,
+)
+
+__all__ = [
+    "BlauTSStochastic",
+]
+
+
+def _price_series(data, mode):
+    key = str(mode).lower()
+    if key in ("1", "close", "price_close"):
+        return data.close
+    if key in ("2", "open", "price_open"):
+        return data.open
+    if key in ("3", "high", "price_high"):
+        return data.high
+    if key in ("4", "low", "price_low"):
+        return data.low
+    if key in ("5", "median", "price_median"):
+        return (data.high + data.low) / 2.0
+    if key in ("6", "typical", "price_typical"):
+        return (data.high + data.low + data.close) / 3.0
+    if key in ("7", "weighted", "price_weighted"):
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if key in ("8", "simple", "price_simpl"):
+        return (data.open + data.close) / 2.0
+    if key in ("9", "quarter", "price_quarter"):
+        return (data.high + data.low + data.open + data.close) / 4.0
+    return data.close
+
+
+class BlauTSStochastic(Indicator):
+    """Blau TS Stochastic: triple-smoothed stochastic momentum oscillator.
+
+    A stochastic numerator (price minus lowest low) and its range (highest high
+    minus lowest low) are each triple-smoothed with EMAs; the histogram is
+    200 times their ratio minus 100 (guarded against division by zero), and an
+    EMA of the histogram forms the signal line exposed on the down line.
+    """
+
+    lines = ("up", "down", "hist")
+    params = (
+        ("xlength", 5),
+        ("xlength1", 20),
+        ("xlength2", 5),
+        ("xlength3", 3),
+        ("xlength4", 3),
+        ("ipc", "close"),
+    )
+
+    def __init__(self):
+        """Build the triple-EMA stochastic chain for the hist/up/down lines."""
+        price = _price_series(self.data, self.p.ipc)
+        hh = Highest(self.data.high, period=int(self.p.xlength))
+        ll = Lowest(self.data.low, period=int(self.p.xlength))
+        stoch = price - ll
+        range_line = hh - ll
+
+        xstoch = EMA(stoch, period=int(self.p.xlength1))
+        xxstoch = EMA(xstoch, period=int(self.p.xlength2))
+        xxxstoch = EMA(xxstoch, period=int(self.p.xlength3))
+
+        xrange = EMA(range_line, period=int(self.p.xlength1))
+        xxrange = EMA(xrange, period=int(self.p.xlength2))
+        xxxrange = EMA(xxrange, period=int(self.p.xlength3))
+
+        hist = btfunc.DivByZero(200.0 * xxxstoch, xxxrange, zero=0.0) - 100.0
+        signal = EMA(hist, period=int(self.p.xlength4))
+
+        self.l.hist = hist
+        self.l.up = hist
+        self.l.down = signal

backtrader/indicators/contrib/blau_tvi.py

@@ -0,0 +1,55 @@
+#!/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 (
+    ExponentialMovingAverage,
+    Indicator,
+)
+
+__all__ = [
+    "BlauTVI",
+]
+
+
+class BlauTVI(Indicator):
+    """Blau Tick Volume Indicator: a triple-EMA-smoothed up/down tick oscillator."""
+
+    lines = ("value", "color_idx")
+    params = (
+        ("xlength1", 12),
+        ("xlength2", 12),
+        ("xlength3", 12),
+    )
+
+    def __init__(self):
+        """Build the up/down tick EMAs and the smoothed oscillator value line."""
+        up_ticks = (self.data.volume + (self.data.close - self.data.open) / 0.01) / 2.0
+        dn_ticks = (self.data.volume - (self.data.close - self.data.open) / 0.01) / 2.0
+        up_1 = ExponentialMovingAverage(up_ticks, period=self.p.xlength1)
+        dn_1 = ExponentialMovingAverage(dn_ticks, period=self.p.xlength1)
+        up_2 = ExponentialMovingAverage(up_1, period=self.p.xlength2)
+        dn_2 = ExponentialMovingAverage(dn_1, period=self.p.xlength2)
+        raw = 100.0 * (up_2 - dn_2) / (up_2 + dn_2 + 1e-12)
+        self.lines.value = ExponentialMovingAverage(raw, period=self.p.xlength3)
+        self.addminperiod(self.p.xlength1 + self.p.xlength2 + self.p.xlength3 + 2)
+
+    def next(self):
+        """Assign a color index based on the value's sign and direction of change."""
+        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 = 2.0
+        if current > 0:
+            color = 4.0 if current > prev else 3.0
+        elif current < 0:
+            color = 0.0 if current < prev else 1.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/brain_trend2_indicator.py

@@ -0,0 +1,128 @@
+#!/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 Indicator
+
+__all__ = [
+    "BrainTrend2Indicator",
+    "AbsolutelyNoLagLwmaIndicator",
+]
+
+
+class BrainTrend2Indicator(Indicator):
+    """ATR-derived trend-state indicator producing a four-state color signal."""
+
+    lines = ("color_state",)
+    params = (
+        ("atr_period", 7),
+        ("point_size", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize transition state and adaptive ATR window."""
+        self._period = max(1, int(self.p.atr_period))
+        self._cecf = 0.7
+        self._trs = deque(maxlen=self._period)
+        self._river = None
+        self._emaxtra = None
+        self.addminperiod(self._period + 2)
+
+    @staticmethod
+    def _finite(value):
+        return value is not None and math.isfinite(value)
+
+    def next(self):
+        """Update trend river state and emit a color code."""
+        prev_close = float(self.data.close[-1]) if len(self.data) > 1 else float(self.data.close[0])
+        spread = (
+            float(getattr(self.data, "spread")[0]) * self.p.point_size
+            if hasattr(self.data, "spread")
+            else 0.0
+        )
+        high = float(self.data.high[0])
+        low = float(self.data.low[0])
+        open_ = float(self.data.open[0])
+        close = float(self.data.close[0])
+        tr = spread + high - low
+        tr = max(tr, abs(spread + high - prev_close), abs(low - prev_close))
+        self._trs.append(tr)
+        if len(self._trs) < self._period:
+            self.lines.color_state[0] = float("nan")
+            return
+        weights = list(range(self._period, 0, -1))
+        atr = (
+            2.0
+            * sum(w * v for w, v in zip(weights, reversed(self._trs)))
+            / (self._period * (self._period + 1.0))
+        )
+        widcha = self._cecf * atr
+        if self._river is None:
+            prev2_close = float(self.data.close[-2]) if len(self.data) > 2 else prev_close
+            self._river = prev2_close > prev_close
+            self._emaxtra = prev_close
+        if self._river and low < self._emaxtra - widcha:
+            self._river = False
+            self._emaxtra = spread + high
+        if (not self._river) and spread + high > self._emaxtra + widcha:
+            self._river = True
+            self._emaxtra = low
+        if self._river and low > self._emaxtra:
+            self._emaxtra = low
+        if (not self._river) and spread + high < self._emaxtra:
+            self._emaxtra = spread + high
+        if self._river:
+            color = 0.0 if open_ <= close else 1.0
+        else:
+            color = 4.0 if open_ >= close else 3.0
+        self.lines.color_state[0] = color
+
+
+class AbsolutelyNoLagLwmaIndicator(Indicator):
+    """No-lag LWMA indicator with color state transitions."""
+
+    lines = ("line_value", "color_state")
+    params = (("length", 7),)
+
+    def __init__(self):
+        """Prepare rolling windows for dual-weighted moving average updates."""
+        self._length = max(1, int(self.p.length))
+        self._price_window = deque(maxlen=self._length)
+        self._lwma_window = deque(maxlen=self._length)
+        self.addminperiod(self._length * 2)
+
+    def _weighted_ma(self, values):
+        weights = list(range(len(values), 0, -1))
+        total = sum(weights)
+        return sum(w * v for w, v in zip(weights, reversed(values))) / total
+
+    def next(self):
+        """Compute smoothed LWMA and directional color for each bar."""
+        price = float(self.data.close[0])
+        self._price_window.append(price)
+        if len(self._price_window) < self._length:
+            self.lines.line_value[0] = float("nan")
+            self.lines.color_state[0] = float("nan")
+            return
+        lwma1 = self._weighted_ma(self._price_window)
+        self._lwma_window.append(lwma1)
+        if len(self._lwma_window) < self._length:
+            self.lines.line_value[0] = float("nan")
+            self.lines.color_state[0] = float("nan")
+            return
+        lwma2 = self._weighted_ma(self._lwma_window)
+        color = 1.0
+        prev = self.lines.line_value[-1] if len(self) > 0 else float("nan")
+        if prev == prev:
+            if prev < lwma2:
+                color = 2.0
+            elif prev > lwma2:
+                color = 0.0
+        self.lines.line_value[0] = lwma2
+        self.lines.color_state[0] = color

backtrader/indicators/contrib/brain_trend_signal_proxy.py

@@ -0,0 +1,47 @@
+#!/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 (
+    AverageTrueRange,
+    Indicator,
+    Stochastic,
+)
+
+__all__ = [
+    "BrainTrendSignalProxy",
+]
+
+
+class BrainTrendSignalProxy(Indicator):
+    """Signal proxy that combines ATR and stochastic cross conditions."""
+
+    lines = ("buy_signal", "sell_signal")
+    params = (
+        ("atr_period", 14),
+        ("sto_period", 12),
+    )
+
+    def __init__(self):
+        """Initialize indicators and required warm-up bars."""
+        self.atr = AverageTrueRange(self.data, period=self.p.atr_period)
+        self.stoch = Stochastic(self.data, period=self.p.sto_period)
+        self.addminperiod(max(self.p.atr_period, self.p.sto_period) + 3)
+
+    def next(self):
+        """Emit buy and sell trigger levels for the latest bar."""
+        buy_signal = 0.0
+        sell_signal = 0.0
+        close0 = float(self.data.close[0])
+        atr0 = float(self.atr[0])
+        k0 = float(self.stoch.percK[0])
+        k1 = float(self.stoch.percK[-1])
+        if k1 <= 20.0 and k0 > 20.0 and close0 > float(self.data.close[-1]) + atr0 * 0.1:
+            buy_signal = close0
+        elif k1 >= 80.0 and k0 < 80.0 and close0 < float(self.data.close[-1]) - atr0 * 0.1:
+            sell_signal = close0
+        self.lines.buy_signal[0] = buy_signal
+        self.lines.sell_signal[0] = sell_signal

backtrader/indicators/contrib/brake_parb_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.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "BrakeParbIndicator",
+]
+
+
+class BrakeParbIndicator(Indicator):
+    """Parabolic-style trailing-stop indicator with flip arrows.
+
+    Maintains a power-curve stop that rises while long (and falls while short)
+    from a begin price; when price breaks the stop the direction flips. Exposes
+    the active stop on ``up``/``down`` lines and direction-flip cues on
+    ``buy``/``sell`` lines.
+    """
+
+    lines = ("buy", "sell", "up", "down")
+    params = (
+        ("a", 1.5),
+        ("b", 1.0),
+        ("bigin_shift", 10.0),
+    )
+
+    def __init__(self):
+        """Set the minimum period and initialize the parabolic-stop state."""
+        self.addminperiod(5)
+        self._is_long = True
+        self._max_price = float("-inf")
+        self._min_price = float("inf")
+        self._begin_bar = 0
+        self._begin_price = None
+
+    def next(self):
+        """Advance the parabolic stop and emit up/down stop and flip lines.
+
+        Extends the stop along the power curve, flips direction (resetting the
+        begin price and extremes) when price breaks the stop, and sets the
+        ``up``/``down`` stop lines plus ``buy``/``sell`` flip cues for the bar.
+        """
+        if self._begin_price is None:
+            self._begin_price = float(self.data.low[0])
+        self._max_price = max(self._max_price, float(self.data.high[0]))
+        self._min_price = min(self._min_price, float(self.data.low[0]))
+        bars_since_begin = max(0, len(self.data) - 1 - self._begin_bar)
+        b = float(self.p.b) * 0.00001 * 15.0
+        bigin_shift = float(self.p.bigin_shift) * 0.00001
+        parab = math.pow(max(0.0, float(bars_since_begin)), float(self.p.a)) * b
+        value = self._begin_price + parab if self._is_long else self._begin_price - parab
+        if self._is_long and value > float(self.data.low[0]):
+            self._is_long = False
+            self._begin_price = self._max_price + bigin_shift
+            self._begin_bar = len(self.data) - 1
+            value = self._begin_price
+            self._max_price = float("-inf")
+            self._min_price = float("inf")
+        elif (not self._is_long) and value < float(self.data.high[0]):
+            self._is_long = True
+            self._begin_price = self._min_price - bigin_shift
+            self._begin_bar = len(self.data) - 1
+            value = self._begin_price
+            self._max_price = float("-inf")
+            self._min_price = float("inf")
+        prev_up = float(self.lines.up[-1]) if len(self) > 0 else 0.0
+        prev_dn = float(self.lines.down[-1]) if len(self) > 0 else 0.0
+        if self._is_long:
+            self.lines.up[0] = value
+            self.lines.down[0] = 0.0
+        else:
+            self.lines.up[0] = 0.0
+            self.lines.down[0] = value
+        self.lines.buy[0] = (
+            self.lines.down[0] if prev_up > 0.0 and float(self.lines.down[0]) > 0.0 else 0.0
+        )
+        self.lines.sell[0] = (
+            self.lines.up[0] if prev_dn > 0.0 and float(self.lines.up[0]) > 0.0 else 0.0
+        )

backtrader/indicators/contrib/breakout_bars_trend_v2.py

@@ -0,0 +1,121 @@
+#!/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__ = [
+    "BreakoutBarsTrendV2",
+]
+
+
+class BreakoutBarsTrendV2(Indicator):
+    """Custom trend-breakout indicator calculating dynamic trend boundaries and reversals.
+
+    Lines:
+        value: Trend state value (1.0 or positive series count for uptrend, -1.0 or negative series count for downtrend).
+    """
+
+    lines = ("value",)
+    params = (
+        ("reversal_mode", "PERCENT"),
+        ("delta", 1.0),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize the indicator parameters, trend tracking states, and seed prices."""
+        self._mode = str(self.p.reversal_mode).upper()
+        self._delta = float(self.p.delta)
+        if self._mode == "PIPS":
+            if self._delta < 30.0:
+                self._delta = 1000.0
+        else:
+            if self._delta < 0.03 or self._delta > 30.0:
+                self._delta = 1.0
+        self._seed_close = None
+        self._seed_high = None
+        self._seed_low = None
+        self._initialized = False
+        self._uptrend = None
+        self._min_price = None
+        self._max_price = None
+        self.addminperiod(1)
+
+    def _reversal_distance(self, price):
+        """Calculate the absolute price pullback distance threshold required for a trend reversal.
+
+        Args:
+            price (float): Extreme reference price.
+
+        Returns:
+            float: Symmetrical price pullback distance.
+        """
+        if self._mode == "PIPS":
+            return float(self._delta) * float(self.p.point)
+        return (float(price) / 100.0) * float(self._delta)
+
+    def next(self):
+        """Determine if a trend reversal has occurred, and update trend extremes."""
+        close = float(self.data.close[0])
+        high = float(self.data.high[0])
+        low = float(self.data.low[0])
+
+        if self._seed_close is None:
+            self._seed_close = close
+            self._seed_high = high
+            self._seed_low = low
+            self.lines.value[0] = 0.0
+            return
+
+        if not self._initialized:
+            reversal = self._reversal_distance(self._seed_close)
+            if abs(close - self._seed_close) - reversal <= 0.00001:
+                self.lines.value[0] = 0.0
+                return
+            if close > self._seed_close:
+                self._initialized = True
+                self._uptrend = True
+                self._min_price = self._seed_low
+                self._max_price = high
+                self.lines.value[0] = 1.0
+            else:
+                self._initialized = True
+                self._uptrend = False
+                self._min_price = low
+                self._max_price = self._seed_high
+                self.lines.value[0] = -1.0
+            return
+
+        prev_value = float(self.lines.value[-1])
+        prev_high = float(self.data.high[-1])
+        prev_low = float(self.data.low[-1])
+
+        self._min_price = min(float(self._min_price), prev_low)
+        self._max_price = max(float(self._max_price), prev_high)
+
+        if self._uptrend:
+            reversal = self._reversal_distance(self._max_price)
+            if close > float(self._max_price):
+                self.lines.value[0] = prev_value + 1.0
+            elif close < max(float(self._max_price), high) - reversal and close < prev_low:
+                self._uptrend = False
+                self.lines.value[0] = -1.0
+                self._max_price = high
+                self._min_price = low
+            else:
+                self.lines.value[0] = prev_value
+        else:
+            reversal = self._reversal_distance(self._min_price)
+            if close < float(self._min_price):
+                self.lines.value[0] = prev_value - 1.0
+            elif close > min(float(self._min_price), low) + reversal and close > prev_high:
+                self._uptrend = True
+                self.lines.value[0] = 1.0
+                self._min_price = low
+                self._max_price = high
+            else:
+                self.lines.value[0] = prev_value

backtrader/indicators/contrib/bsi_indicator.py

@@ -0,0 +1,87 @@
+#!/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__ = [
+    "BSIIndicator",
+]
+
+
+class BSIIndicator(Indicator):
+    """Balance of power-style indicator returning BSI value and trend color."""
+
+    lines = ("bsi", "color")
+    params = (
+        ("range_period", 20),
+        ("slowing", 3),
+        ("avg_period", 3),
+        ("volume_mode", "TICK"),
+    )
+
+    def __init__(self):
+        """Set minimum period and initialize smoothing configuration."""
+        self.addminperiod(
+            int(self.p.range_period) + int(self.p.slowing) + int(self.p.avg_period) + 3
+        )
+
+    def _component(self, ago):
+        sumpos = 0.0
+        sumneg = 0.0
+        sumhigh = 0.0
+        for k in range(int(self.p.slowing)):
+            idx = ago + k
+            highs = [float(self.data.high[-(idx + j)]) for j in range(int(self.p.range_period))]
+            lows = [float(self.data.low[-(idx + j)]) for j in range(int(self.p.range_period))]
+            hh = max(highs)
+            ll = min(lows)
+            rng = max(hh - ll, 1e-12)
+            bark_close = float(self.data.close[-idx])
+            bark_prev_close = float(self.data.close[-(idx + 1)])
+            bark_high = float(self.data.high[-idx])
+            bark_low = float(self.data.low[-idx])
+            sp = bark_high - bark_low
+            if self.p.volume_mode == "NONE":
+                vol = 1.0
+            elif self.p.volume_mode == "VOLUME":
+                vmax = max(
+                    float(self.data.openinterest[-(idx + j)])
+                    for j in range(int(self.p.range_period))
+                )
+                vol = float(self.data.openinterest[-idx]) / vmax if vmax else 0.0
+            else:
+                vmax = max(
+                    float(self.data.volume[-(idx + j)]) for j in range(int(self.p.range_period))
+                )
+                vol = float(self.data.volume[-idx]) / vmax if vmax else 0.0
+            ratio = 0.0
+            if not (bark_prev_close - sp * 0.2 > bark_close):
+                ratio = 1.0 if bark_low == ll else (hh - bark_low) / rng
+                sumpos += (bark_close - bark_low) * ratio * vol
+            if not (bark_prev_close + sp * 0.2 < bark_close):
+                ratio = 1.0 if bark_high == hh else (bark_high - ll) / rng
+                sumneg += (bark_high - bark_close) * ratio * vol * -1.0
+            sumhigh += rng
+        if not sumhigh:
+            return 0.0
+        return (sumpos / sumhigh * 100.0) + (sumneg / sumhigh * 100.0)
+
+    def next(self):
+        """Compute BSI and derive color from directional BSI movement."""
+        vals = [self._component(i) for i in range(int(self.p.avg_period))]
+        bsi = sum(vals) / float(int(self.p.avg_period))
+        self.lines.bsi[0] = bsi
+        if len(self) < 2:
+            self.lines.color[0] = 1.0
+            return
+        prev = float(self.lines.bsi[-1])
+        color = 1.0
+        if prev > bsi:
+            color = 0.0
+        if prev < bsi:
+            color = 2.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/bulls_bears_eyes.py

@@ -0,0 +1,67 @@
+#!/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,
+)
+
+__all__ = [
+    "BullsBearsEyes",
+]
+
+
+class BullsBearsEyes(Indicator):
+    """Rebuild a signal oscillator from recursive smoothed directional momentum."""
+
+    lines = ("value",)
+    params = (
+        ("period", 13),
+        ("gamma", 0.6),
+    )
+
+    def __init__(self):
+        """Initialize EMA and recursive helper state used by the indicator."""
+        self.ema = ExponentialMovingAverage(self.data.close, period=int(self.p.period))
+        self.addminperiod(int(self.p.period) + 5)
+        self._l0 = 0.0
+        self._l1 = 0.0
+        self._l2 = 0.0
+        self._l3 = 0.0
+
+    def next(self):
+        """Compute the next recursive signal value and write it to ``lines.value``."""
+        bulls = float(self.data.high[0] - self.ema[0])
+        bears = float(self.data.low[0] - self.ema[0])
+        gamma = float(self.p.gamma)
+        l0a = self._l0
+        l1a = self._l1
+        l2a = self._l2
+        l3a = self._l3
+        l0 = (1.0 - gamma) * (bears + bulls) + gamma * l0a
+        l1 = -gamma * l0 + l0a + gamma * l1a
+        l2 = -gamma * l1 + l1a + gamma * l2a
+        l3 = -gamma * l2 + l2a + gamma * l3a
+        cu = 0.0
+        cd = 0.0
+        if l0 >= l1:
+            cu += l0 - l1
+        else:
+            cd += l1 - l0
+        if l1 >= l2:
+            cu += l1 - l2
+        else:
+            cd += l2 - l1
+        if l2 >= l3:
+            cu += l2 - l3
+        else:
+            cd += l3 - l2
+        self.lines.value[0] = cu / (cu + cd) if (cu + cd) != 0.0 else 0.0
+        self._l0 = l0
+        self._l1 = l1
+        self._l2 = l2
+        self._l3 = l3