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

backtrader/indicators/contrib/price_channel_stop_indicator.py

@@ -0,0 +1,104 @@
+#!/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__ = [
+    "PriceChannelStopIndicator",
+]
+
+
+class PriceChannelStopIndicator(Indicator):
+    """Reconstructs PriceChannel_Stop from its MQ5 source.
+
+    6 output buffers mapped to lines:
+      0=DownTrendSignal, 1=DownTrendBuffer, 2=DownTrendLine
+      3=UpTrendSignal,   4=UpTrendBuffer,   5=UpTrendLine
+    """
+
+    lines = ("down_signal", "down_buffer", "down_line", "up_signal", "up_buffer", "up_line")
+    params = (
+        ("channel_period", 5),
+        ("risk", 0.1),
+    )
+
+    def __init__(self):
+        """Initialize oscillator state and force initial warm-up period."""
+        self._cp = int(self.p.channel_period)
+        self._risk = float(self.p.risk)
+        self._trend = 0
+        self._prev_bsmax = 0.0
+        self._prev_bsmin = 0.0
+        self.addminperiod(self._cp + 2)
+
+    def next(self):
+        """Update indicator lines from current and rolling high/low windows."""
+        cp = self._cp
+        risk = self._risk
+
+        # Highest high and lowest low over [bar, bar+ChannelPeriod)
+        hi = max(float(self.data.high[-i]) for i in range(cp))
+        lo = min(float(self.data.low[-i]) for i in range(cp))
+
+        d_price = (hi - lo) * risk
+        bsmax = hi - d_price
+        bsmin = lo + d_price
+
+        cur_close = float(self.data.close[0])
+
+        if cur_close > self._prev_bsmax:
+            self._trend = 1
+        if cur_close < self._prev_bsmin:
+            self._trend = -1
+
+        # Ratchet
+        if self._trend > 0 and bsmin < self._prev_bsmin:
+            bsmin = self._prev_bsmin
+        if self._trend < 0 and bsmax > self._prev_bsmax:
+            bsmax = self._prev_bsmax
+
+        # Reset all
+        self.lines.down_signal[0] = 0.0
+        self.lines.down_buffer[0] = 0.0
+        self.lines.down_line[0] = 0.0
+        self.lines.up_signal[0] = 0.0
+        self.lines.up_buffer[0] = 0.0
+        self.lines.up_line[0] = 0.0
+
+        prev_down_buffer = (
+            float(self.lines.down_buffer[-1])
+            if len(self) > 1 and not math.isnan(float(self.lines.down_buffer[-1]))
+            else 0.0
+        )
+        prev_up_buffer = (
+            float(self.lines.up_buffer[-1])
+            if len(self) > 1 and not math.isnan(float(self.lines.up_buffer[-1]))
+            else 0.0
+        )
+
+        if self._trend > 0:
+            price = bsmin
+            if prev_down_buffer > 0:
+                self.lines.up_signal[0] = price
+                self.lines.up_line[0] = price
+            else:
+                self.lines.up_buffer[0] = price
+                self.lines.up_line[0] = price
+
+        if self._trend < 0:
+            price = bsmax
+            if prev_up_buffer > 0:
+                self.lines.down_signal[0] = price
+                self.lines.down_line[0] = price
+            else:
+                self.lines.down_buffer[0] = price
+                self.lines.down_line[0] = price
+
+        self._prev_bsmax = bsmax
+        self._prev_bsmin = bsmin

backtrader/indicators/contrib/price_extreme_channel.py

@@ -0,0 +1,35 @@
+#!/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__ = [
+    "PriceExtremeChannel",
+]
+
+
+class PriceExtremeChannel(Indicator):
+    """Custom indicator calculating local highest highs and lowest lows.
+
+    Lines:
+        upper (Line): Channel upper boundary.
+        lower (Line): Channel lower boundary.
+    """
+
+    lines = ("upper", "lower")
+    params = (("multiplier", 5),)
+
+    def __init__(self):
+        """Initialize the custom highest/lowest channel lines and establish minimum warmup period."""
+        period = max(int(self.p.multiplier), 1)
+        self.lines.upper = Highest(self.data.high(-1), period=period)
+        self.lines.lower = Lowest(self.data.low(-1), period=period)
+        self.addminperiod(period + 2)

backtrader/indicators/contrib/qqe_cloud_indicator.py

@@ -0,0 +1,129 @@
+#!/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,
+    RelativeStrengthIndex,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "QQECloudIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve moving-average class from strategy configuration value."""
+    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
+
+
+class QQECloudIndicator(Indicator):
+    """Indicator computing smoothed QQE-like trend values from RSI.
+
+    Args:
+        rsi_period: RSI lookback period.
+        sf: Smoothing factor for XRSI and momentum smoothers.
+        darfactor: ATR-like factor used to offset trailing reference.
+        xma_method: Moving-average method alias used for RSI smoothing.
+        xphase: Unused legacy parameter preserved for compatibility.
+    """
+
+    lines = ("up", "down")
+    params = (
+        ("rsi_period", 14),
+        ("sf", 5),
+        ("darfactor", 4.236),
+        ("xma_method", "sma"),
+        ("xphase", 15),
+    )
+
+    def __init__(self):
+        """Initialize RSI, smoothed RSI, and momentum smoothing components."""
+        self._rsi = RelativeStrengthIndex(self.data.close, period=max(2, int(self.p.rsi_period)))
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        self._xrsi = ma_cls(self._rsi, period=max(1, int(self.p.sf)))
+        wilders_period = max(2, int(self.p.rsi_period) * 2 - 1)
+        self._mom = abs(self._xrsi - self._xrsi(-1))
+        self._xmom = ma_cls(self._mom, period=wilders_period)
+        self._xxmom = ma_cls(self._xmom, period=wilders_period)
+        self.addminperiod(int(self.p.rsi_period) + int(self.p.sf) + wilders_period * 2 + 5)
+
+    def next(self):
+        """Update output lines on each tick using previous envelope state."""
+        xrsi = float(self._xrsi[0])
+        prev_xrsi = float(self._xrsi[-1])
+        dar = float(self._xxmom[0]) * float(self.p.darfactor)
+        prev_tr = float(self.lines.down[-1]) if len(self) > 0 else 50.0
+        if prev_tr != prev_tr:
+            prev_tr = 50.0
+        tr = prev_tr
+        dv = tr
+        if xrsi < tr:
+            tr = xrsi + dar
+            if prev_xrsi < dv and tr > dv:
+                tr = dv
+        elif xrsi > tr:
+            tr = xrsi - dar
+            if prev_xrsi > dv and tr < dv:
+                tr = dv
+        self.lines.up[0] = xrsi
+        self.lines.down[0] = tr
+
+    def once(self, start, end):
+        """Vectorized indicator evaluation for vectorized Backtrader runs."""
+        xrsi_array = self._xrsi.array
+        xxmom_array = self._xxmom.array
+        up_line = self.lines.up.array
+        down_line = self.lines.down.array
+        for line in (up_line, down_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        prev_tr = 50.0
+        actual_end = min(end, len(xrsi_array), len(xxmom_array))
+        for i in range(start, actual_end):
+            xrsi = float(xrsi_array[i])
+            prev_xrsi = float(xrsi_array[i - 1]) if i > 0 else xrsi
+            dar = float(xxmom_array[i]) * float(self.p.darfactor)
+            tr = prev_tr
+            dv = tr
+            if xrsi < tr:
+                tr = xrsi + dar
+                if prev_xrsi < dv and tr > dv:
+                    tr = dv
+            elif xrsi > tr:
+                tr = xrsi - dar
+                if prev_xrsi > dv and tr < dv:
+                    tr = dv
+            up_line[i] = xrsi
+            down_line[i] = tr
+            prev_tr = tr

backtrader/indicators/contrib/ravi_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 (
+    ExponentialMovingAverage,
+    Indicator,
+)
+
+__all__ = [
+    "RaviIndicator",
+]
+
+
+class RaviIndicator(Indicator):
+    """RAVI oscillator: percentage spread between a fast and slow EMA of close."""
+
+    lines = ("ravi",)
+    params = (
+        ("fast_length", 7),
+        ("slow_length", 65),
+    )
+
+    def __init__(self):
+        """Build the fast/slow EMAs and set the indicator warmup period."""
+        self.fast_ma = ExponentialMovingAverage(self.data.close, period=self.p.fast_length)
+        self.slow_ma = ExponentialMovingAverage(self.data.close, period=self.p.slow_length)
+        self.addminperiod(self.p.slow_length + 3)
+
+    def next(self):
+        """Compute the RAVI value as the percent spread of fast over slow EMA."""
+        slow = float(self.slow_ma[0])
+        if abs(slow) <= 1e-12:
+            value = 0.0
+        else:
+            value = 100.0 * (float(self.fast_ma[0]) - slow) / slow
+        self.lines.ravi[0] = value

backtrader/indicators/contrib/raw_close_close_stochastic.py

@@ -0,0 +1,74 @@
+#!/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__ = [
+    "RawCloseCloseStochastic",
+    "CloseCloseEmaStochastic",
+]
+
+
+class RawCloseCloseStochastic(Indicator):
+    """Raw close-based Stochastic (%K numerator) over a close-only window."""
+
+    lines = ("raw",)
+    params = (("period", 5),)
+
+    def __init__(self):
+        """Set the minimum period required before emitting values."""
+        self.addminperiod(int(self.p.period))
+
+    def next(self):
+        """Compute the raw close-based Stochastic value for the current bar."""
+        period = int(self.p.period)
+        closes = [float(self.data.close[-i]) for i in range(period)]
+        highest = max(closes)
+        lowest = min(closes)
+        denom = highest - lowest
+        if denom == 0:
+            self.lines.raw[0] = 0.0
+            return
+        self.lines.raw[0] = 100.0 * (float(self.data.close[0]) - lowest) / denom
+
+    def once(self, start, end):
+        """Vectorized raw close-based Stochastic over the array index range.
+
+        Args:
+            start: Start index (inclusive) of the range to compute.
+            end: End index (exclusive) of the range to compute.
+        """
+        period = int(self.p.period)
+        closes = self.data.close.array
+        raw = self.lines.raw.array
+        for i in range(start, end):
+            window_start = max(0, i - period + 1)
+            window = closes[window_start : i + 1]
+            highest = max(window)
+            lowest = min(window)
+            denom = highest - lowest
+            raw[i] = 0.0 if denom == 0 else 100.0 * (closes[i] - lowest) / denom
+
+
+class CloseCloseEmaStochastic(Indicator):
+    """EMA-smoothed close-based Stochastic exposing ``percK`` and ``percD``."""
+
+    lines = ("percK", "percD")
+    params = (
+        ("period", 5),
+        ("slowing", 3),
+        ("dperiod", 3),
+    )
+
+    def __init__(self):
+        """Build the EMA-smoothed %K and %D lines from the raw Stochastic."""
+        raw = RawCloseCloseStochastic(self.data, period=int(self.p.period))
+        self.lines.percK = ExponentialMovingAverage(raw, period=int(self.p.slowing))
+        self.lines.percD = ExponentialMovingAverage(self.lines.percK, period=int(self.p.dperiod))

backtrader/indicators/contrib/rd_trend_trigger_indicator.py

@@ -0,0 +1,51 @@
+#!/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__ = [
+    "RDTrendTriggerIndicator",
+]
+
+
+class RDTrendTriggerIndicator(Indicator):
+    """Custom indicator that derives normalized range-trend trigger values."""
+
+    lines = ("value",)
+    params = (
+        ("regress", 15),
+        ("t3_length", 5),
+        ("t3_phase", 70),
+    )
+
+    def __init__(self):
+        """Initialize helper buffers and required warmup length."""
+        self._ema = ExponentialMovingAverage(self.lines.value, period=max(1, int(self.p.t3_length)))
+        self.addminperiod(int(self.p.regress) * 2 + int(self.p.t3_length) + 3)
+
+    def next(self):
+        """Compute trend trigger value from rolling high/low comparisons."""
+        regress = int(self.p.regress)
+        highs_recent = [float(self.data.high[-i]) for i in range(regress)]
+        highs_older = [float(self.data.high[-regress - i]) for i in range(regress)]
+        lows_recent = [float(self.data.low[-i]) for i in range(regress)]
+        lows_older = [float(self.data.low[-regress - i]) for i in range(regress)]
+        highest_high_recent = max(highs_recent)
+        highest_high_older = max(highs_older)
+        lowest_low_recent = min(lows_recent)
+        lowest_low_older = min(lows_older)
+        buy_power = highest_high_recent - lowest_low_older
+        sell_power = highest_high_older - lowest_low_recent
+        denom = buy_power + sell_power
+        ttf = ((buy_power - sell_power) / (0.5 * denom) * 100.0) if denom else 0.0
+        prev = float(self.lines.value[-1]) if len(self) > 0 else ttf
+        period = max(1, int(self.p.t3_length))
+        alpha = 2.0 / (period + 1.0)
+        self.lines.value[0] = alpha * ttf + (1.0 - alpha) * prev

backtrader/indicators/contrib/renko_level.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__ = [
+    "RenkoLevel",
+]
+
+
+class RenkoLevel(Indicator):
+    """Fixed-brick Renko level tracker emitting upper/lower levels and color."""
+
+    lines = ("upper", "lower", "color_idx")
+    params = (
+        ("size_of_block", 30),
+        ("point_size", 0.01),
+    )
+
+    def __init__(self):
+        """Precompute the brick price step and epsilon, set minimum period."""
+        self.step_price = self.p.size_of_block * self.p.point_size
+        self.eps = self.p.point_size * 0.1
+        self.addminperiod(1)
+
+    def _levels(self, price):
+        """Round a price to its enclosing Renko brick levels.
+
+        Args:
+            price: The price to snap to the brick grid.
+
+        Returns:
+            A tuple ``(price_ceil, price_round, price_floor)`` of brick levels.
+        """
+        step = self.step_price
+        price_round = round(price / step) * step
+        price_ceil = math.ceil((price_round + step / 2.0) / step) * step
+        price_floor = math.floor((price_round - step / 2.0) / step) * step
+        return price_ceil, price_round, price_floor
+
+    def next(self):
+        """Advance the Renko brick levels for the current bar's close."""
+        close_price = float(self.data.close[0])
+        if (
+            len(self) == 1
+            or not math.isfinite(float(self.lines.upper[-1]))
+            or not math.isfinite(float(self.lines.lower[-1]))
+        ):
+            price_ceil, price_round, price_floor = self._levels(close_price)
+            self.lines.upper[0] = price_round
+            self.lines.lower[0] = price_floor
+            self.lines.color_idx[0] = 0.0
+            return
+        prev_up = float(self.lines.upper[-1])
+        prev_down = float(self.lines.lower[-1])
+        prev_color = (
+            float(self.lines.color_idx[-1])
+            if math.isfinite(float(self.lines.color_idx[-1]))
+            else 0.0
+        )
+        price_ceil, price_round, price_floor = self._levels(close_price)
+        upper = prev_up
+        lower = prev_down
+        color = prev_color
+        if prev_down <= close_price <= prev_up:
+            pass
+        elif close_price < prev_down:
+            if abs(price_round - prev_down) > self.eps:
+                upper = price_ceil
+                lower = price_round
+                color = 1.0
+        elif close_price > prev_up:
+            if abs(price_round - prev_up) > self.eps:
+                lower = price_floor
+                upper = price_round
+                color = 0.0
+        self.lines.upper[0] = upper
+        self.lines.lower[0] = lower
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/renko_line_break.py

@@ -0,0 +1,91 @@
+#!/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__ = [
+    "RenkoLineBreak",
+]
+
+
+class RenkoLineBreak(Indicator):
+    """Indicator that models renko-like box transitions."""
+
+    lines = ("upper", "lower", "boxes")
+    params = (
+        ("min_box_size", 500),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize box size and state."""
+        box_size = float(self.p.min_box_size)
+        if box_size < 0:
+            box_size = 300.0
+        self._box_size = box_size * float(self.p.point)
+        self._seed_close = None
+        self._initialized = False
+        self._up = False
+        self.addminperiod(1)
+
+    def next(self):
+        """Update Renko upper/lower/box count states each bar."""
+        price = float(self.data.close[0])
+
+        if self._seed_close is None:
+            self._seed_close = price
+            self.lines.upper[0] = 0.0
+            self.lines.lower[0] = 0.0
+            self.lines.boxes[0] = 0.0
+            return
+
+        if not self._initialized:
+            if abs(price - self._seed_close) < self._box_size:
+                self.lines.upper[0] = 0.0
+                self.lines.lower[0] = 0.0
+                self.lines.boxes[0] = 0.0
+                return
+            if price > self._seed_close:
+                self.lines.upper[0] = price
+                self.lines.lower[0] = self._seed_close
+                self.lines.boxes[0] = 1.0
+                self._up = True
+            else:
+                self.lines.upper[0] = self._seed_close
+                self.lines.lower[0] = price
+                self.lines.boxes[0] = -1.0
+                self._up = False
+            self._initialized = True
+            return
+
+        prev_up = float(self.lines.upper[-1])
+        prev_dn = float(self.lines.lower[-1])
+        prev_boxes = float(self.lines.boxes[-1])
+
+        if price >= prev_up + self._box_size:
+            self.lines.upper[0] = price
+            self.lines.lower[0] = prev_up
+            if self._up:
+                self.lines.boxes[0] = prev_boxes + 1.0
+            else:
+                self._up = True
+                self.lines.boxes[0] = 1.0
+            return
+
+        if price <= prev_dn - self._box_size:
+            self.lines.upper[0] = prev_dn
+            self.lines.lower[0] = price
+            if self._up:
+                self._up = False
+                self.lines.boxes[0] = -1.0
+            else:
+                self.lines.boxes[0] = prev_boxes - 1.0
+            return
+
+        self.lines.upper[0] = prev_up
+        self.lines.lower[0] = prev_dn
+        self.lines.boxes[0] = prev_boxes

backtrader/indicators/contrib/rftl_indicator.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 Indicator
+
+__all__ = [
+    "RFTLIndicator",
+]
+
+
+RFTL_WEIGHTS = [
+    -0.0025097319,
+    0.0513007762,
+    0.1142800493,
+    0.1699342860,
+    0.2025269304,
+    0.2025269304,
+    0.1699342860,
+    0.1142800493,
+    0.0513007762,
+    -0.0025097319,
+]
+
+
+class RFTLIndicator(Indicator):
+    """Indicator that computes a weighted RFTL value from weighted close history."""
+
+    lines = ("rftl",)
+    params = (("weights", tuple(RFTL_WEIGHTS)),)
+
+    def __init__(self):
+        """Build the RFTL weighted sum and enforce warmup period."""
+        total = 0.0
+        for idx, weight in enumerate(self.p.weights):
+            total += float(weight) * self.data.close(-idx)
+        self.lines.rftl = total
+        self.addminperiod(len(self.p.weights) + 1)