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

backtrader/indicators/contrib/trvi_indicator.py

@@ -0,0 +1,194 @@
+#!/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 collections import deque
+
+from .. import (
+    EMA,
+    RSI,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "TRVIIndicator",
+    "ColorRMACDIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Return a Backtrader moving-average class by symbolic name.
+
+    Args:
+        name: Indicator name alias like ``sma``, ``ema``, or ``smma``.
+
+    Returns:
+        class: A Backtrader indicator class object.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SMA
+    if mode in {"ema", "mode_ema"}:
+        return EMA
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+class RollingWeightedAverage:
+    """Weighted moving-average helper with recency-biased linear weights."""
+
+    def __init__(self, period):
+        """Create deque state for the rolling weighted average window.
+
+        Args:
+            period: Number of bars included in each weighted average.
+        """
+        self.period = max(1, int(period))
+        self.values = deque(maxlen=self.period)
+
+    def update(self, value):
+        """Push a value and return the weighted mean of the window.
+
+        Args:
+            value: Incoming numeric sample.
+
+        Returns:
+            float: Linear recency-weighted average of buffered values.
+        """
+        self.values.append(float(value))
+        weights = list(range(len(self.values), 0, -1))
+        return sum(v * w for v, w in zip(self.values, weights)) / sum(weights)
+
+
+class TRVIIndicator(Indicator):
+    """TRVI indicator combining price-range velocity with volume-weighted smoothing."""
+
+    lines = (
+        "trvi",
+        "signal",
+    )
+    params = (
+        ("period", 26),
+        ("volume_type", "tick"),
+    )
+
+    def __init__(self):
+        """Create helper averages and internal signal buffer."""
+        self._num_avg = RollingWeightedAverage(self.p.period)
+        self._den_avg = RollingWeightedAverage(self.p.period)
+        self._signal_window = deque(maxlen=4)
+        self.addminperiod(self.p.period + 8)
+
+    def _volume(self):
+        if str(self.p.volume_type).lower() == "real":
+            return (
+                float(self.data.openinterest[0])
+                if len(self.data.openinterest)
+                else float(self.data.volume[0])
+            )
+        return float(self.data.volume[0])
+
+    def _count_val(
+        self,
+        a_now,
+        b_now,
+        a_prev1,
+        b_prev1,
+        a_prev2,
+        b_prev2,
+        a_prev3,
+        b_prev3,
+        vol_now,
+        vol_prev1,
+        vol_prev2,
+        vol_prev3,
+    ):
+        return (
+            vol_now * (a_now - b_now)
+            + 8.0 * vol_prev1 * (a_prev1 - b_prev1)
+            + 8.0 * vol_prev2 * (a_prev2 - b_prev2)
+            + vol_prev3 * (a_prev3 - b_prev3)
+        )
+
+    def next(self):
+        """Compute TRVI and smoothed signal for the current bar."""
+        volume_now = self._volume()
+        volume_prev1 = float(self.data.volume[-1])
+        volume_prev2 = float(self.data.volume[-2])
+        volume_prev3 = float(self.data.volume[-3])
+        num_value = self._count_val(
+            float(self.data.close[0]),
+            float(self.data.open[0]),
+            float(self.data.close[-1]),
+            float(self.data.open[-1]),
+            float(self.data.close[-2]),
+            float(self.data.open[-2]),
+            float(self.data.close[-3]),
+            float(self.data.open[-3]),
+            volume_now,
+            volume_prev1,
+            volume_prev2,
+            volume_prev3,
+        )
+        den_value = self._count_val(
+            float(self.data.high[0]),
+            float(self.data.low[0]),
+            float(self.data.high[-1]),
+            float(self.data.low[-1]),
+            float(self.data.high[-2]),
+            float(self.data.low[-2]),
+            float(self.data.high[-3]),
+            float(self.data.low[-3]),
+            volume_now,
+            volume_prev1,
+            volume_prev2,
+            volume_prev3,
+        )
+        smooth_num = self._num_avg.update(num_value)
+        smooth_den = self._den_avg.update(den_value)
+        trvi_value = smooth_num / smooth_den if smooth_den else 0.0
+        self.lines.trvi[0] = trvi_value
+        self._signal_window.appendleft(trvi_value)
+        if len(self._signal_window) == 4:
+            self.lines.signal[0] = (
+                4.0 * self._signal_window[0]
+                + 3.0 * self._signal_window[1]
+                + 2.0 * self._signal_window[2]
+                + self._signal_window[3]
+            ) / 10.0
+        else:
+            self.lines.signal[0] = trvi_value
+
+
+class ColorRMACDIndicator(Indicator):
+    """Custom RMACD composite indicator with configurable signal MA."""
+
+    lines = (
+        "rmacd",
+        "signal",
+    )
+    params = (
+        ("fast_rvi", 12),
+        ("slow_trvi", 26),
+        ("volume_type", "tick"),
+        ("signal_method", "sma"),
+        ("signal_xma", 9),
+    )
+
+    def __init__(self):
+        """Build RMACD components and required minimum period."""
+        ma_cls = resolve_ma_class(self.p.signal_method)
+        self.rvi = RSI(self.data.close, period=self.p.fast_rvi, safediv=True)
+        self.trvi = TRVIIndicator(
+            self.data, period=self.p.slow_trvi, volume_type=self.p.volume_type
+        )
+        self.lines.rmacd = self.rvi - self.trvi.signal
+        self.lines.signal = ma_cls(self.lines.rmacd, period=self.p.signal_xma)
+        self.addminperiod(max(self.p.fast_rvi, self.p.slow_trvi + 8, self.p.signal_xma) + 5)

backtrader/indicators/contrib/two_pb_ideal_xosma_indicator.py

@@ -0,0 +1,127 @@
+#!/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 collections import deque
+
+from .. import Indicator
+
+__all__ = [
+    "TwoPbIdealXOSMAIndicator",
+]
+
+
+class TwoPbIdealXOSMAIndicator(Indicator):
+    """Compute the smoothed 2pbIdealXOSMA histogram from cascaded ideal-MAs."""
+
+    lines = ("signal",)
+    params = (
+        ("period1", 10),
+        ("period2", 10),
+        ("periodx1", 10),
+        ("periodx2", 10),
+        ("periody1", 10),
+        ("periody2", 10),
+        ("periodz1", 10),
+        ("periodz2", 10),
+        ("smooth_method", "jjma"),
+        ("smooth_period", 9),
+        ("smooth_phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize ideal-MA stage weights, recursive states, and min period."""
+        self._w1 = 1.0 / max(1, int(self.p.period1))
+        self._w2 = 1.0 / max(1, int(self.p.period2))
+        self._wx1 = 1.0 / max(1, int(self.p.periodx1))
+        self._wx2 = 1.0 / max(1, int(self.p.periodx2))
+        self._wy1 = 1.0 / max(1, int(self.p.periody1))
+        self._wy2 = 1.0 / max(1, int(self.p.periody2))
+        self._wz1 = 1.0 / max(1, int(self.p.periodz1))
+        self._wz2 = 1.0 / max(1, int(self.p.periodz2))
+        self._fast_state = None
+        self._moving01 = None
+        self._moving11 = None
+        self._moving21 = None
+        self._smooth_state = None
+        self._smooth_values = deque(maxlen=max(1, int(self.p.smooth_period)))
+        self.addminperiod(
+            max(
+                int(self.p.period1),
+                int(self.p.period2),
+                int(self.p.periodx1),
+                int(self.p.periodx2),
+                int(self.p.periody1),
+                int(self.p.periody2),
+                int(self.p.periodz1),
+                int(self.p.periodz2),
+                int(self.p.smooth_period),
+            )
+            + 5
+        )
+
+    @staticmethod
+    def _ideal_ma_smooth(weight_1, weight_2, series_1, series_0, result_1):
+        dseries = series_0 - series_1
+        dseries2 = dseries * dseries - 1.0
+        denominator = 1.0 + weight_2 * dseries2
+        if denominator == 0:
+            return result_1
+        return (
+            weight_1 * (series_0 - result_1) + result_1 + weight_2 * result_1 * dseries2
+        ) / denominator
+
+    def _smooth_histogram(self, value):
+        method = str(self.p.smooth_method).lower()
+        period = max(1, int(self.p.smooth_period))
+        if method == "sma":
+            self._smooth_values.append(value)
+            return sum(self._smooth_values) / len(self._smooth_values)
+        if method == "lwma":
+            self._smooth_values.append(value)
+            values = list(self._smooth_values)
+            weights = list(range(1, len(values) + 1))
+            return sum(v * w for v, w in zip(values, weights)) / sum(weights)
+        if method == "smma":
+            if self._smooth_state is None:
+                self._smooth_state = value
+            else:
+                self._smooth_state = ((period - 1) * self._smooth_state + value) / period
+            return self._smooth_state
+        alpha = 2.0 / (period + 1.0)
+        if self._smooth_state is None:
+            self._smooth_state = value
+        else:
+            self._smooth_state = self._smooth_state + alpha * (value - self._smooth_state)
+        return self._smooth_state
+
+    def next(self):
+        """Advance the ideal-MA cascade and emit the smoothed histogram value."""
+        price = float(self.data.close[0])
+        prev_price = float(self.data.close[-1]) if len(self.data) > 1 else price
+        if self._fast_state is None:
+            self._fast_state = price
+            self._moving01 = price
+            self._moving11 = price
+            self._moving21 = price
+
+        self._fast_state = self._ideal_ma_smooth(
+            self._w1, self._w2, prev_price, price, self._fast_state
+        )
+        moving00 = self._ideal_ma_smooth(self._wx1, self._wx2, prev_price, price, self._moving01)
+        moving10 = self._ideal_ma_smooth(
+            self._wy1, self._wy2, self._moving01, moving00, self._moving11
+        )
+        moving20 = self._ideal_ma_smooth(
+            self._wz1, self._wz2, self._moving11, moving10, self._moving21
+        )
+
+        self._moving01 = moving00
+        self._moving11 = moving10
+        self._moving21 = moving20
+
+        raw_macd = self._fast_state - moving20
+        self.lines.signal[0] = self._smooth_histogram(raw_macd)

backtrader/indicators/contrib/ultra_absolutely_no_lag_lwma_color.py

@@ -0,0 +1,92 @@
+#!/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 (
+    Highest,
+    Indicator,
+    Lowest,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "UltraAbsolutelyNoLagLwmaColor",
+]
+
+
+class UltraAbsolutelyNoLagLwmaColor(Indicator):
+    """Low-lag LWMA range-position oscillator emitting bulls/bears and color.
+
+    Positions a smoothed weighted moving average within its recent high/low
+    range to produce bulls/bears strength lines and a color state encoding their
+    dominance and slope across configurable up/down levels.
+    """
+
+    lines = ("bulls", "bears", "color_idx")
+    params = (
+        ("flength", 7),
+        ("start_length", 5),
+        ("pstep", 2),
+        ("psteps_total", 10),
+        ("smooth_length", 3),
+        ("up_level", 80.0),
+        ("dn_level", 20.0),
+    )
+
+    def __init__(self):
+        """Build the range high/low and smoothing averages, set min period."""
+        lookback = max(
+            self.p.flength * 2,
+            self.p.start_length + self.p.pstep * self.p.psteps_total,
+            self.p.smooth_length + 2,
+        )
+        self.range_high = Highest(self.data.high, period=max(2, self.p.flength * 2))
+        self.range_low = Lowest(self.data.low, period=max(2, self.p.flength * 2))
+        self.smooth_close = WeightedMovingAverage(
+            self.data.close, period=max(2, self.p.start_length + self.p.pstep)
+        )
+        self.smooth_signal = WeightedMovingAverage(
+            self.smooth_close, period=max(2, self.p.smooth_length)
+        )
+        self.addminperiod(lookback + 2)
+
+    def next(self):
+        """Compute bulls/bears strengths and the color state for this bar."""
+        high = float(self.range_high[0])
+        low = float(self.range_low[0])
+        spread = high - low
+        if spread <= 0:
+            bulls = 50.0
+        else:
+            bulls = (float(self.smooth_close[0]) - low) / spread * 100.0
+        bulls = max(0.0, min(100.0, bulls))
+        bears = 100.0 - bulls
+        self.lines.bulls[0] = bulls
+        self.lines.bears[0] = bears
+        prev_bulls = (
+            float(self.lines.bulls[-1])
+            if len(self) > 1 and math.isfinite(float(self.lines.bulls[-1]))
+            else bulls
+        )
+        prev_bears = (
+            float(self.lines.bears[-1])
+            if len(self) > 1 and math.isfinite(float(self.lines.bears[-1]))
+            else bears
+        )
+        color = 0.0
+        if bulls > bears:
+            if bulls > self.p.up_level or bears < self.p.dn_level:
+                color = 7.0 if prev_bulls <= bulls else 8.0
+            else:
+                color = 5.0 if prev_bulls <= bulls else 6.0
+        elif bulls < bears:
+            if bulls < self.p.dn_level or bears > self.p.up_level:
+                color = 1.0 if prev_bears <= bears else 2.0
+            else:
+                color = 3.0 if prev_bears <= bears else 4.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/ultra_wpr_indicator.py

@@ -0,0 +1,173 @@
+#!/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,
+    WilliamsR,
+)
+
+__all__ = [
+    "UltraWPRIndicator",
+]
+
+
+class CountSmoother:
+    """Incremental moving-average smoother supporting several MA methods.
+
+    Maintains rolling state so each ``update`` call returns the smoothed value
+    for one of the SMA, LWMA/JJMA, SMMA, or EMA methods.
+    """
+
+    def __init__(self, method, period):
+        """Initialize the smoother.
+
+        Args:
+            method: Smoothing method name (e.g. ``sma``, ``lwma``, ``smma``).
+            period: Smoothing window length (clamped to at least 1).
+        """
+        self.method = str(method).lower()
+        self.period = max(1, int(period))
+        self.values = deque(maxlen=self.period)
+        self.state = None
+
+    def update(self, value):
+        """Add a new sample and return the updated smoothed value.
+
+        Args:
+            value: The new raw value to incorporate.
+
+        Returns:
+            The smoothed value after including ``value``.
+        """
+        value = float(value)
+        if self.method in {"sma", "mode_sma"}:
+            self.values.append(value)
+            return sum(self.values) / len(self.values)
+        if self.method in {"lwma", "mode_lwma", "jjma", "mode_jjma"}:
+            self.values.append(value)
+            weights = list(range(1, len(self.values) + 1))
+            return sum(v * w for v, w in zip(self.values, weights)) / sum(weights)
+        if self.method in {"smma", "mode_smma"}:
+            if self.state is None:
+                self.state = value
+            else:
+                self.state = ((self.period - 1) * self.state + value) / self.period
+            return self.state
+        alpha = 2.0 / (self.period + 1.0)
+        if self.state is None:
+            self.state = value
+        else:
+            self.state = self.state + alpha * (value - self.state)
+        return self.state
+
+
+class UltraWPRIndicator(Indicator):
+    """Ultra Williams %R oscillator emitting bulls and bears strength lines."""
+
+    lines = (
+        "bulls",
+        "bears",
+    )
+    params = (
+        ("wpr_period", 13),
+        ("w_method", "jjma"),
+        ("start_length", 3),
+        ("w_phase", 100),
+        ("xstep", 5),
+        ("xsteps_total", 10),
+        ("smooth_method", "jjma"),
+        ("smooth_length", 3),
+        ("smooth_phase", 100),
+    )
+
+    def __init__(self):
+        """Build the WPR fan, per-length smoothers, and output smoothers."""
+        self._periods = [
+            int(self.p.start_length + self.p.xstep * i) for i in range(int(self.p.xsteps_total) + 1)
+        ]
+        self._wpr_indicators = [
+            WilliamsR(self.data, period=self.p.wpr_period) for _ in self._periods
+        ]
+        self._smoothers = [CountSmoother(self.p.w_method, period) for period in self._periods]
+        self._prev_values = [None for _ in self._periods]
+        self._bull_smoother = CountSmoother(self.p.smooth_method, self.p.smooth_length)
+        self._bear_smoother = CountSmoother(self.p.smooth_method, self.p.smooth_length)
+        self.addminperiod(self.p.wpr_period + max(self._periods) + self.p.smooth_length + 5)
+
+    def next(self):
+        """Count rising vs falling smoothed WPR lines and emit bulls/bears."""
+        upsch = 0.0
+        dnsch = 0.0
+        current_values = []
+        base_wpr = float(self._wpr_indicators[0][0])
+        if math.isnan(base_wpr):
+            self.lines.bulls[0] = float("nan")
+            self.lines.bears[0] = float("nan")
+            return
+        for index, smoother in enumerate(self._smoothers):
+            value = smoother.update(base_wpr)
+            current_values.append(value)
+            prev = self._prev_values[index]
+            if prev is None:
+                continue
+            if value > prev:
+                upsch += 1.0
+            else:
+                dnsch += 1.0
+        self.lines.bulls[0] = self._bull_smoother.update(upsch)
+        self.lines.bears[0] = self._bear_smoother.update(dnsch)
+        self._prev_values = current_values
+
+    def once(self, start, end):
+        """Vectorized batch computation of bulls/bears over a bar range.
+
+        Args:
+            start: Index of the first bar to compute (inclusive).
+            end: Index just past the last bar to compute (exclusive).
+        """
+        base_wpr_array = self._wpr_indicators[0].lines[0].array
+        bulls_line = self.lines.bulls.array
+        bears_line = self.lines.bears.array
+        for line in (bulls_line, bears_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        smoothers = [CountSmoother(self.p.w_method, period) for period in self._periods]
+        prev_values = [None for _ in self._periods]
+        bull_smoother = CountSmoother(self.p.smooth_method, self.p.smooth_length)
+        bear_smoother = CountSmoother(self.p.smooth_method, self.p.smooth_length)
+        actual_end = min(end, len(base_wpr_array))
+        for i in range(start, actual_end):
+            upsch = 0.0
+            dnsch = 0.0
+            current_values = []
+            base_wpr = float(base_wpr_array[i])
+            if math.isnan(base_wpr):
+                bulls_line[i] = float("nan")
+                bears_line[i] = float("nan")
+                continue
+            for index, smoother in enumerate(smoothers):
+                value = smoother.update(base_wpr)
+                current_values.append(value)
+                prev = prev_values[index]
+                if prev is None:
+                    continue
+                if value > prev:
+                    upsch += 1.0
+                else:
+                    dnsch += 1.0
+            bulls_line[i] = bull_smoother.update(upsch)
+            bears_line[i] = bear_smoother.update(dnsch)
+            prev_values = current_values
+
+        self._smoothers = smoothers
+        self._prev_values = prev_values
+        self._bull_smoother = bull_smoother
+        self._bear_smoother = bear_smoother

backtrader/indicators/contrib/up_down_candle_strength.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "UpDownCandleStrength",
+]
+
+
+class UpDownCandleStrength(Indicator):
+    """Up Down Candle Strength Indicator.
+
+    This indicator calculates the strength of price movement by measuring
+    the ratio of up candles to down candles over a specified period.
+
+    The strength value ranges from 0.0 (all down candles) to 1.0 (all up candles),
+    with 0.5 indicating an equal number of up and down candles.
+
+    Attributes:
+        lines.strength: The calculated strength ratio (0.0 to 1.0).
+        params.period: The number of periods to analyze for candle strength.
+
+    Note:
+        A strength value of 0.5 is returned when there are no clear up or down
+        candles (i.e., all candles have equal open and close prices).
+    """
+
+    lines = ("strength",)
+    params = (("period", 20),)
+
+    def __init__(self):
+        """Initialize the UpDownCandleStrength indicator.
+
+        Sets the minimum period required for calculation based on the
+        configured period parameter.
+        """
+        self.addminperiod(self.p.period)
+
+    def next(self):
+        """Calculate the candle strength ratio for the current bar.
+
+        Counts the number of up candles (close > open) and down candles
+        (close < open) over the specified period and calculates the ratio.
+
+        The strength value is calculated as:
+            strength = up_count / (up_count + down_count)
+
+        If no candles have clear directional movement (all open == close),
+        the strength is set to 0.5 (neutral).
+        """
+        up_count = 0
+        down_count = 0
+        for i in range(self.p.period):
+            if self.data.close[-i] > self.data.open[-i]:
+                up_count += 1
+            elif self.data.close[-i] < self.data.open[-i]:
+                down_count += 1
+
+        total = up_count + down_count
+        if total == 0:
+            self.lines.strength[0] = 0.5
+        else:
+            self.lines.strength[0] = up_count / total