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

backtrader/indicators/contrib/xma_range_bands_indicator.py

@@ -0,0 +1,107 @@
+#!/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,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "XMARangeBandsIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average name to its backtrader indicator class.
+
+    Args:
+        name: Moving-average mode name (e.g. ``'sma'``, ``'ema'``, ``'smma'``).
+
+    Returns:
+        The matching backtrader moving-average indicator class, defaulting to
+        the weighted moving average for unrecognized names.
+    """
+    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
+
+
+def resolve_price_line(data, mode):
+    """Map an applied-price mode to a price line built from the data feed.
+
+    Args:
+        data: The data feed providing open/high/low/close lines.
+        mode: Applied-price mode name (e.g. ``'price_close'``, ``'median'``,
+            ``'typical'``, ``'weighted'``).
+
+    Returns:
+        A line expression for the requested applied price, defaulting to close.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_open", "open"}:
+        return data.open
+    if price_mode in {"price_high", "high"}:
+        return data.high
+    if price_mode in {"price_low", "low"}:
+        return data.low
+    if price_mode in {"price_median", "median"}:
+        return (data.high + data.low) / 2.0
+    if price_mode in {"price_typical", "typical"}:
+        return (data.high + data.low + data.close) / 3.0
+    if price_mode in {"price_weighted", "weighted"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if price_mode in {"price_simpl", "simpl"}:
+        return (data.open + data.close) / 2.0
+    if price_mode in {"price_quarter", "quarter"}:
+        return (data.high + data.low + data.open + data.close) / 4.0
+    if price_mode in {"price_trendfollow0", "trendfollow0"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if price_mode in {"price_trendfollow1", "trendfollow1"}:
+        return (data.high + data.low + data.open + data.close + data.close) / 5.0
+    return data.close
+
+
+class XMARangeBandsIndicator(Indicator):
+    """Moving-average midline with range-scaled upper and lower bands."""
+
+    lines = (
+        "mid",
+        "upper",
+        "lower",
+    )
+    params = (
+        ("ma_method1", "sma"),
+        ("length1", 100),
+        ("phase1", 15),
+        ("ma_method2", "jjma"),
+        ("length2", 20),
+        ("phase2", 100),
+        ("deviation", 2.0),
+        ("ipc", "price_close"),
+        ("price_shift", 0),
+    )
+
+    def __init__(self):
+        """Build the midline MA and range MA, then derive the band lines."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        ma_cls_1 = resolve_ma_class(self.p.ma_method1)
+        ma_cls_2 = resolve_ma_class(self.p.ma_method2)
+        self._base = ma_cls_1(price_line, period=self.p.length1)
+        bar_range = self.data.high - self.data.low
+        self._range_ma = ma_cls_2(bar_range, period=self.p.length2)
+        self.lines.mid = self._base + self.p.price_shift
+        self.lines.upper = self.lines.mid + self._range_ma * self.p.deviation
+        self.lines.lower = self.lines.mid - self._range_ma * self.p.deviation
+        self.addminperiod(max(self.p.length1, self.p.length2) + 3)

backtrader/indicators/contrib/xmacd_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 (
+    EMA,
+    SMA,
+    Indicator,
+)
+
+__all__ = [
+    "XMACDIndicator",
+]
+
+
+class XMACDIndicator(Indicator):
+    """Configurable MACD indicator with selectable MA methods and price.
+
+    Computes the MACD line as the difference of a fast and slow moving average
+    of a chosen applied price, then a signal line by smoothing the MACD. The
+    moving-average type, signal-smoothing type, periods and applied price are all
+    configurable via parameters.
+    """
+
+    lines = (
+        "macd",
+        "signal",
+    )
+    params = (
+        ("ma_method", "ema"),
+        ("signal_method", "sma"),
+        ("fast_period", 12),
+        ("slow_period", 26),
+        ("signal_period", 9),
+        ("applied_price", "close"),
+    )
+
+    def __init__(self):
+        """Build the fast/slow MAs, MACD and signal lines and set min period."""
+        ma_cls = EMA if str(self.p.ma_method).lower() == "ema" else SMA
+        signal_cls = EMA if str(self.p.signal_method).lower() == "ema" else SMA
+        price = self._price_line()
+        fast = ma_cls(price, period=self.p.fast_period)
+        slow = ma_cls(price, period=self.p.slow_period)
+        self.lines.macd = fast - slow
+        self.lines.signal = signal_cls(self.lines.macd, period=self.p.signal_period)
+        self.addminperiod(max(self.p.fast_period, self.p.slow_period) + self.p.signal_period + 5)
+
+    def _price_line(self):
+        mode = str(self.p.applied_price).lower()
+        if mode == "open":
+            return self.data.open
+        if mode == "high":
+            return self.data.high
+        if mode == "low":
+            return self.data.low
+        if mode == "median":
+            return (self.data.high + self.data.low) / 2.0
+        if mode == "typical":
+            return (self.data.high + self.data.low + self.data.close) / 3.0
+        if mode == "weighted":
+            return (self.data.high + self.data.low + self.data.close + self.data.close) / 4.0
+        if mode == "simpl":
+            return (self.data.open + self.data.close) / 2.0
+        if mode == "quarter":
+            return (self.data.high + self.data.low + self.data.open + self.data.close) / 4.0
+        return self.data.close

backtrader/indicators/contrib/xrsi_de_marker_histogram.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.
+"""
+
+import math
+
+from .. import (
+    RSI,
+    DeMarker,
+    Indicator,
+)
+
+__all__ = [
+    "XrsiDeMarkerHistogram",
+]
+
+
+class XrsiDeMarkerHistogram(Indicator):
+    """Blend RSI and DeMarker into a smoothed histogram line."""
+
+    lines = ("value",)
+    params = (
+        ("ind_period", 14),
+        ("rsi_price", "close"),
+        ("high_level", 60.0),
+        ("low_level", 40.0),
+        ("xma_method", "SMA"),
+        ("x_length", 5),
+        ("x_phase", 15),
+    )
+
+    def __init__(self):
+        """Instantiate RSI and DeMarker and initialize smoothing buffers."""
+        self.rsi = RSI(self.data.close, period=self.p.ind_period)
+        self.demarker = DeMarker(self.data, period=self.p.ind_period)
+        self._raw_buf = []
+        self._smooth_prev = None
+        self.addminperiod(self.p.ind_period + self.p.x_length + 5)
+
+    def _smooth_value(self, raw_value):
+        method = str(self.p.xma_method).upper()
+        if method in ("MODE_SMA_", "SMA"):
+            period = max(1, int(self.p.x_length))
+            if len(self._raw_buf) < period:
+                return raw_value
+            return sum(self._raw_buf[-period:]) / float(period)
+
+        length = max(1, int(self.p.x_length))
+        phase = max(-100, min(100, int(self.p.x_phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if self._smooth_prev is None or not math.isfinite(self._smooth_prev):
+            smooth = raw_value
+        else:
+            smooth = self._smooth_prev + alpha * (raw_value - self._smooth_prev)
+        self._smooth_prev = smooth
+        return smooth
+
+    def next(self):
+        """Compute and smooth the combined histogram value."""
+        raw_value = (float(self.rsi[0]) + 100.0 * float(self.demarker.demarker[0])) / 2.0
+        self._raw_buf.append(raw_value)
+        self.lines.value[0] = self._smooth_value(raw_value)

backtrader/indicators/contrib/xrsi_histogram_vol_direct_indicator.py

@@ -0,0 +1,52 @@
+#!/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__ = [
+    "XRSIHistogramVolDirectIndicator",
+]
+
+
+class XRSIHistogramVolDirectIndicator(Indicator):
+    """Simple direct XRSI histogram indicator that emits color state transitions."""
+
+    lines = ("color_state", "value")
+    params = (
+        ("rsi_period", 14),
+        ("ma_length", 12),
+    )
+
+    def __init__(self):
+        """Initialize rolling history for smoothed direct RSI histogram."""
+        self._scaled_history = []
+        self.addminperiod(max(self.p.rsi_period, self.p.ma_length) + 3)
+
+    def next(self):
+        """Update scaled RSI values and binary color direction."""
+        gains = []
+        losses = []
+        for idx in range(self.p.rsi_period):
+            delta = float(self.data.close[-idx]) - float(self.data.close[-idx - 1])
+            gains.append(max(delta, 0.0))
+            losses.append(max(-delta, 0.0))
+        avg_gain = sum(gains) / float(len(gains))
+        avg_loss = sum(losses) / float(len(losses))
+        if avg_loss <= 1e-12:
+            rsi_value = 100.0 if avg_gain > 0 else 50.0
+        else:
+            rs = avg_gain / avg_loss
+            rsi_value = 100.0 - (100.0 / (1.0 + rs))
+        raw = (rsi_value - 50.0) * float(self.data.volume[0])
+        self._scaled_history.append(raw)
+        if len(self._scaled_history) > self.p.ma_length:
+            self._scaled_history.pop(0)
+        current = sum(self._scaled_history) / float(len(self._scaled_history))
+        previous = self.lines.value[-1] if len(self) else 0.0
+        color = 0.0 if current >= previous else 1.0
+        self.lines.value[0] = current
+        self.lines.color_state[0] = color

backtrader/indicators/contrib/xrsi_histogram_vol_indicator.py

@@ -0,0 +1,81 @@
+#!/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__ = [
+    "XRSIHistogramVolIndicator",
+]
+
+
+class XRSIHistogramVolIndicator(Indicator):
+    """Volume-scaled RSI histogram indicator producing directional color states."""
+
+    lines = ("color_state", "value", "max_level", "up_level", "dn_level", "min_level")
+    params = (
+        ("rsi_period", 14),
+        ("high_level2", 17),
+        ("high_level1", 5),
+        ("low_level1", -5),
+        ("low_level2", -17),
+        ("ma_length", 12),
+    )
+
+    def __init__(self):
+        """Prepare rolling RSI and volume histories."""
+        self._scaled_history = []
+        self._volume_history = []
+        self.addminperiod(max(self.p.rsi_period, self.p.ma_length) + 3)
+
+    def next(self):
+        """Calculate scaled histogram level and classify it into a color state."""
+        vol = float(self.data.volume[0]) if len(self.data.volume) else 0.0
+        gains = []
+        losses = []
+        for idx in range(self.p.rsi_period):
+            delta = float(self.data.close[-idx]) - float(self.data.close[-idx - 1])
+            gains.append(max(delta, 0.0))
+            losses.append(max(-delta, 0.0))
+        avg_gain = sum(gains) / float(len(gains))
+        avg_loss = sum(losses) / float(len(losses))
+        if avg_loss <= 1e-12:
+            rsi_value = 100.0 if avg_gain > 0 else 50.0
+        else:
+            rs = avg_gain / avg_loss
+            rsi_value = 100.0 - (100.0 / (1.0 + rs))
+        raw = (rsi_value - 50.0) * vol
+        self._scaled_history.append(raw)
+        self._volume_history.append(vol)
+        if len(self._scaled_history) > self.p.ma_length:
+            self._scaled_history.pop(0)
+        if len(self._volume_history) > self.p.ma_length:
+            self._volume_history.pop(0)
+        scaled = sum(self._scaled_history) / float(len(self._scaled_history))
+        avg_vol = (
+            sum(self._volume_history) / float(len(self._volume_history))
+            if self._volume_history
+            else max(vol, 1.0)
+        )
+        max_level = self.p.high_level2 * avg_vol
+        up_level = self.p.high_level1 * avg_vol
+        dn_level = self.p.low_level1 * avg_vol
+        min_level = self.p.low_level2 * avg_vol
+        clr = 2.0
+        if scaled > max_level:
+            clr = 0.0
+        elif scaled > up_level:
+            clr = 1.0
+        elif scaled < min_level:
+            clr = 4.0
+        elif scaled < dn_level:
+            clr = 3.0
+        self.lines.value[0] = scaled
+        self.lines.max_level[0] = max_level
+        self.lines.up_level[0] = up_level
+        self.lines.dn_level[0] = dn_level
+        self.lines.min_level[0] = min_level
+        self.lines.color_state[0] = clr

backtrader/indicators/contrib/xrvi_indicator.py

@@ -0,0 +1,130 @@
+#!/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__ = [
+    "XRVIIndicator",
+]
+
+
+class XRVIIndicator(Indicator):
+    """Compute a custom XRVI oscillator and its smoothed signal line.
+
+    The indicator relies on candle body delta normalized by range and applies
+    configurable moving-average methods to build both XRVI and signal streams.
+    """
+
+    lines = (
+        "xrvi",
+        "signal",
+    )
+    params = (
+        ("rvi_method", "jurx"),
+        ("rvi_period", 10),
+        ("rvi_phase", 15),
+        ("sign_method", "jurx"),
+        ("sign_period", 5),
+        ("sign_phase", 15),
+    )
+
+    def __init__(self):
+        """Initialize XRVI indicator with a minimal required lookback length."""
+        self.addminperiod(self.p.rvi_period + self.p.sign_period + 3)
+
+    def _raw_rvi_at(self, i, open_array, high_array, low_array, close_array):
+        denom = float(high_array[i]) - float(low_array[i])
+        return (float(close_array[i]) - float(open_array[i])) / denom if denom else 0.0
+
+    def _window_ma(self, values, method, period, previous=None):
+        if not values:
+            return float("nan")
+        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 {"sma", "mode_sma"}:
+            return sum(values) / len(values)
+        weights = list(range(1, len(values) + 1))
+        return sum(v * w for v, w in zip(values, weights)) / sum(weights)
+
+    def _raw_rvi_ago(self, ago):
+        denom = float(self.data.high[-ago]) - float(self.data.low[-ago])
+        return (
+            (float(self.data.close[-ago]) - float(self.data.open[-ago])) / denom if denom else 0.0
+        )
+
+    def next(self):
+        """Advance XRVI and signal values for the current bar."""
+        rvi_period = max(1, int(self.p.rvi_period))
+        sign_period = max(1, int(self.p.sign_period))
+        raw_window = [
+            self._raw_rvi_ago(ago) for ago in range(min(len(self), rvi_period) - 1, -1, -1)
+        ]
+        prev_xrvi = float(self.lines.xrvi[-1]) if len(self) > 1 else None
+        xrvi = self._window_ma(raw_window, self.p.rvi_method, rvi_period, prev_xrvi)
+        self.lines.xrvi[0] = xrvi
+        signal_values = []
+        for ago in range(min(len(self), sign_period) - 1, 0, -1):
+            value = float(self.lines.xrvi[-ago])
+            if value == value:
+                signal_values.append(value)
+        signal_values.append(xrvi)
+        prev_signal = float(self.lines.signal[-1]) if len(self) > 1 else None
+        self.lines.signal[0] = self._window_ma(
+            signal_values, self.p.sign_method, sign_period, prev_signal
+        )
+
+    def once(self, start, end):
+        """Vectorized XRVI and signal computation used by Backtrader runonce mode.
+
+        Args:
+            start: First bar index to fill into line arrays.
+            end: Exclusive bar index end bound for computed slices.
+        """
+        open_array = self.data.open.array
+        high_array = self.data.high.array
+        low_array = self.data.low.array
+        close_array = self.data.close.array
+        xrvi_line = self.lines.xrvi.array
+        signal_line = self.lines.signal.array
+        for line in (xrvi_line, signal_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        rvi_period = max(1, int(self.p.rvi_period))
+        sign_period = max(1, int(self.p.sign_period))
+        prev_xrvi = None
+        prev_signal = None
+        actual_end = min(end, len(open_array), len(high_array), len(low_array), len(close_array))
+        raw_values = [
+            self._raw_rvi_at(i, open_array, high_array, low_array, close_array)
+            for i in range(actual_end)
+        ]
+        xrvi_values = []
+        for i in range(actual_end):
+            raw_start = max(0, i - rvi_period + 1)
+            xrvi = self._window_ma(
+                raw_values[raw_start : i + 1], self.p.rvi_method, rvi_period, prev_xrvi
+            )
+            xrvi_values.append(xrvi)
+            if i >= start:
+                xrvi_line[i] = xrvi
+            prev_xrvi = xrvi
+            signal_start = max(0, i - sign_period + 1)
+            signal_values = xrvi_values[signal_start : i + 1]
+            signal = self._window_ma(signal_values, self.p.sign_method, sign_period, prev_signal)
+            if i >= start:
+                signal_line[i] = signal
+            prev_signal = signal

backtrader/indicators/contrib/zero_lag_macd.py

@@ -0,0 +1,36 @@
+#!/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__ = [
+    "ZeroLagMacd",
+]
+
+
+class ZeroLagMacd(Indicator):
+    """Zero-lag MACD indicator using double-smoothed EMA differences."""
+
+    lines = ("macd", "signal")
+    params = (
+        ("fast", 12),
+        ("slow", 26),
+    )
+
+    def __init__(self):
+        """Build fast/slow ZLEMA components and signal line."""
+        ema_fast = ExponentialMovingAverage(self.data, period=self.p.fast)
+        ema_fast2 = ExponentialMovingAverage(ema_fast, period=self.p.fast)
+        zlema_fast = 2.0 * ema_fast - ema_fast2
+        ema_slow = ExponentialMovingAverage(self.data, period=self.p.slow)
+        ema_slow2 = ExponentialMovingAverage(ema_slow, period=self.p.slow)
+        zlema_slow = 2.0 * ema_slow - ema_slow2
+        self.lines.macd = zlema_fast - zlema_slow
+        self.lines.signal = ExponentialMovingAverage(self.lines.macd, period=9)

backtrader/indicators/contrib/zig_zag_recent_pivot_signal.py

@@ -0,0 +1,90 @@
+#!/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__ = [
+    "ZigZagRecentPivotSignal",
+]
+
+
+class ZigZagRecentPivotSignal(Indicator):
+    """Custom indicator tracking local pivot age and pivot price breakout channels.
+
+    Lines:
+        signal (Line): Pivot direction signal line (1 for high, -1 for low).
+        pivot_age (Line): Age of the confirmed pivot in bars.
+        pivot_price (Line): Confirmed pivot price level.
+    """
+
+    lines = ("signal", "pivot_age", "pivot_price")
+    params = (
+        ("depth", 17),
+        ("deviation", 7),
+        ("backstep", 5),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize indicator buffers and establish minimum warmup period."""
+        self.addminperiod(self.p.depth + self.p.backstep + 2)
+        self._last_pivot_type = 0
+        self._last_pivot_price = None
+        self._latest_signal = 0
+        self._latest_age = 999999
+        self._latest_pivot_price = 0.0
+
+    def next(self):
+        """Calculate local ZigZag pivot high and low levels on each new bar."""
+        self.lines.signal[0] = 0
+        self.lines.pivot_age[0] = self._latest_age if self._latest_age < 999999 else 999999
+        self.lines.pivot_price[0] = self._latest_pivot_price
+
+        if len(self.data) <= self.p.depth + self.p.backstep:
+            return
+
+        shift = self.p.backstep
+        candidate_high = float(self.data.high[-shift])
+        candidate_low = float(self.data.low[-shift])
+        high_window = [float(self.data.high[-shift - i]) for i in range(self.p.depth)]
+        low_window = [float(self.data.low[-shift - i]) for i in range(self.p.depth)]
+        deviation_abs = self.p.deviation * self.p.point
+
+        pivot_type = 0
+        pivot_price = None
+        if candidate_high >= max(high_window):
+            pivot_type = 1
+            pivot_price = candidate_high
+        elif candidate_low <= min(low_window):
+            pivot_type = -1
+            pivot_price = candidate_low
+
+        if pivot_type != 0 and pivot_price is not None:
+            is_new_pivot = False
+            if (
+                self._last_pivot_price is None
+                or pivot_type != self._last_pivot_type
+                and abs(pivot_price - self._last_pivot_price) >= deviation_abs
+            ):
+                is_new_pivot = True
+            elif pivot_type == self._last_pivot_type:
+                if pivot_type == 1 and pivot_price > self._last_pivot_price:
+                    is_new_pivot = True
+                if pivot_type == -1 and pivot_price < self._last_pivot_price:
+                    is_new_pivot = True
+            if is_new_pivot:
+                self._last_pivot_type = pivot_type
+                self._last_pivot_price = pivot_price
+                self._latest_signal = 1 if pivot_type == 1 else -1
+                self._latest_age = 0
+                self._latest_pivot_price = pivot_price
+
+        if self._latest_age < 999999:
+            self.lines.signal[0] = self._latest_signal
+            self.lines.pivot_age[0] = self._latest_age
+            self.lines.pivot_price[0] = self._latest_pivot_price
+            self._latest_age += 1