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

backtrader/indicators/contrib/binary_wave_indicator.py

@@ -0,0 +1,233 @@
+#!/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 (
+    CCI,
+    EMA,
+    MACD,
+    RSI,
+    SMA,
+    Indicator,
+    MinusDirectionalIndicator,
+    PlusDirectionalIndicator,
+)
+
+__all__ = [
+    "BinaryWaveIndicator",
+]
+
+
+class BinaryWaveIndicator(Indicator):
+    """Weighted indicator that builds a smoothed wave signal from multiple sub-indicators."""
+
+    lines = (
+        "wave",
+        "raw",
+    )
+    params = (
+        ("weight_ma", 1.0),
+        ("weight_macd", 1.0),
+        ("weight_osma", 1.0),
+        ("weight_cci", 1.0),
+        ("weight_mom", 1.0),
+        ("weight_rsi", 1.0),
+        ("weight_adx", 1.0),
+        ("ma_period", 13),
+        ("ma_type", "ema"),
+        ("fast_macd", 12),
+        ("slow_macd", 26),
+        ("signal_macd", 9),
+        ("cci_period", 14),
+        ("mom_period", 14),
+        ("rsi_period", 14),
+        ("adx_period", 14),
+        ("smooth_period", 5),
+    )
+
+    def __init__(self):
+        """Instantiate sub-indicators and configure required minimum periods."""
+        ma_type = str(self.p.ma_type).lower()
+        ma_cls = EMA if ma_type == "ema" else SMA
+        self.ma = ma_cls(self.data.close, period=self.p.ma_period)
+        self.macd = MACD(
+            self.data.close,
+            period_me1=self.p.fast_macd,
+            period_me2=self.p.slow_macd,
+            period_signal=self.p.signal_macd,
+        )
+        self.cci = CCI(self.data, period=self.p.cci_period)
+        self.rsi = RSI(self.data.close, period=self.p.rsi_period)
+        self.plus_di = PlusDirectionalIndicator(self.data, period=self.p.adx_period)
+        self.minus_di = MinusDirectionalIndicator(self.data, period=self.p.adx_period)
+        self.addminperiod(
+            max(
+                self.p.ma_period,
+                self.p.slow_macd + self.p.signal_macd,
+                self.p.cci_period,
+                self.p.mom_period + 1,
+                self.p.rsi_period,
+                self.p.adx_period,
+                self.p.smooth_period,
+            )
+            + 5
+        )
+
+    def _momentum_ratio(self, idx=0):
+        base_idx = idx - self.p.mom_period
+        base = float(self.data.close[base_idx])
+        if base == 0:
+            return 100.0
+        return float(self.data.close[idx]) / base * 100.0
+
+    def _score(self):
+        score = 0.0
+        if self.p.weight_ma > 0:
+            if float(self.data.close[0]) > float(self.ma[0]):
+                score += self.p.weight_ma
+            elif float(self.data.close[0]) < float(self.ma[0]):
+                score -= self.p.weight_ma
+        if self.p.weight_macd > 0:
+            macd_now = float(self.macd.macd[0])
+            macd_prev = float(self.macd.macd[-1])
+            if macd_now > macd_prev:
+                score += self.p.weight_macd
+            elif macd_now < macd_prev:
+                score -= self.p.weight_macd
+        if self.p.weight_osma > 0:
+            osma = float(self.macd.macd[0] - self.macd.signal[0])
+            if osma > 0:
+                score += self.p.weight_osma
+            elif osma < 0:
+                score -= self.p.weight_osma
+        if self.p.weight_cci > 0:
+            cci = float(self.cci[0])
+            if cci > 0:
+                score += self.p.weight_cci
+            elif cci < 0:
+                score -= self.p.weight_cci
+        if self.p.weight_mom > 0:
+            mom = self._momentum_ratio(0)
+            if mom > 100.0:
+                score += self.p.weight_mom
+            elif mom < 100.0:
+                score -= self.p.weight_mom
+        if self.p.weight_rsi > 0:
+            rsi = float(self.rsi[0])
+            if rsi > 50.0:
+                score += self.p.weight_rsi
+            elif rsi < 50.0:
+                score -= self.p.weight_rsi
+        if self.p.weight_adx > 0:
+            plus_di = float(self.plus_di[0])
+            minus_di = float(self.minus_di[0])
+            if plus_di > minus_di:
+                score += self.p.weight_adx
+            elif plus_di < minus_di:
+                score -= self.p.weight_adx
+        return score
+
+    def next(self):
+        """Update raw and smoothed wave values for a single bar."""
+        raw = self._score()
+        self.lines.raw[0] = raw
+        if len(self) == 1:
+            self.lines.wave[0] = raw
+            return
+        alpha = 2.0 / (self.p.smooth_period + 1.0)
+        prev_wave = float(self.lines.wave[-1])
+        if prev_wave != prev_wave:
+            prev_wave = raw
+        self.lines.wave[0] = prev_wave + alpha * (raw - prev_wave)
+
+    def once(self, start, end):
+        """Calculate raw and smoothed wave arrays for a range of bars.
+
+        Args:
+            start: Start index for batch evaluation.
+            end: End index (exclusive) for batch evaluation.
+        """
+        close_array = self.data.close.array
+        ma_array = self.ma.array
+        macd_array = self.macd.macd.array
+        macd_signal_array = self.macd.signal.array
+        cci_array = self.cci.array
+        rsi_array = self.rsi.array
+        plus_di_array = self.plus_di.array
+        minus_di_array = self.minus_di.array
+        wave_line = self.lines.wave.array
+        raw_line = self.lines.raw.array
+        for line in (wave_line, raw_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        alpha = 2.0 / (self.p.smooth_period + 1.0)
+        prev_wave = None
+        actual_end = min(
+            end,
+            len(close_array),
+            len(ma_array),
+            len(macd_array),
+            len(macd_signal_array),
+            len(cci_array),
+            len(rsi_array),
+            len(plus_di_array),
+            len(minus_di_array),
+        )
+        for i in range(start, actual_end):
+            score = 0.0
+            close = float(close_array[i])
+            if self.p.weight_ma > 0:
+                ma = float(ma_array[i])
+                if close > ma:
+                    score += self.p.weight_ma
+                elif close < ma:
+                    score -= self.p.weight_ma
+            if self.p.weight_macd > 0 and i > 0:
+                macd_now = float(macd_array[i])
+                macd_prev = float(macd_array[i - 1])
+                if macd_now > macd_prev:
+                    score += self.p.weight_macd
+                elif macd_now < macd_prev:
+                    score -= self.p.weight_macd
+            if self.p.weight_osma > 0:
+                osma = float(macd_array[i]) - float(macd_signal_array[i])
+                if osma > 0:
+                    score += self.p.weight_osma
+                elif osma < 0:
+                    score -= self.p.weight_osma
+            if self.p.weight_cci > 0:
+                cci = float(cci_array[i])
+                if cci > 0:
+                    score += self.p.weight_cci
+                elif cci < 0:
+                    score -= self.p.weight_cci
+            if self.p.weight_mom > 0:
+                base_idx = i - int(self.p.mom_period)
+                base = float(close_array[base_idx]) if base_idx >= 0 else 0.0
+                mom = close / base * 100.0 if base else 100.0
+                if mom > 100.0:
+                    score += self.p.weight_mom
+                elif mom < 100.0:
+                    score -= self.p.weight_mom
+            if self.p.weight_rsi > 0:
+                rsi = float(rsi_array[i])
+                if rsi > 50.0:
+                    score += self.p.weight_rsi
+                elif rsi < 50.0:
+                    score -= self.p.weight_rsi
+            if self.p.weight_adx > 0:
+                plus_di = float(plus_di_array[i])
+                minus_di = float(minus_di_array[i])
+                if plus_di > minus_di:
+                    score += self.p.weight_adx
+                elif plus_di < minus_di:
+                    score -= self.p.weight_adx
+
+            raw_line[i] = score
+            wave = score if prev_wave is None else prev_wave + alpha * (score - prev_wave)
+            wave_line[i] = wave
+            prev_wave = wave

backtrader/indicators/contrib/blau_c_momentum_indicator.py

@@ -0,0 +1,123 @@
+#!/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,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "BlauCMomentumIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average mode name to a backtrader indicator class.
+
+    Args:
+        name: The MA mode name (e.g. ``sma``, ``ema``, ``smma``, or a MODE_*
+            alias).
+
+    Returns:
+        The matching backtrader moving-average indicator class, defaulting to
+        the weighted moving average for unrecognised names.
+    """
+    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
+
+
+def resolve_price_line(data, mode):
+    """Map a price mode name to the corresponding feed price line.
+
+    Args:
+        data: The data feed whose OHLC lines are referenced.
+        mode: The price mode name (e.g. ``close``, ``median``, ``typical``,
+            ``weighted``).
+
+    Returns:
+        The selected price line or derived price expression, defaulting to the
+        close for unrecognised modes.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_close", "close"}:
+        return data.close
+    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 (2.0 * data.close + data.high + data.low) / 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
+    return data.close
+
+
+class BlauCMomentumIndicator(Indicator):
+    """Blau composite momentum: triple-smoothed price-difference oscillator."""
+
+    lines = ("value",)
+    params = (
+        ("xma_method", "ema"),
+        ("xlength", 1),
+        ("xlength1", 20),
+        ("xlength2", 5),
+        ("xlength3", 3),
+        ("xphase", 15),
+        ("ipc1", "price_close"),
+        ("ipc2", "price_open"),
+    )
+
+    def __init__(self):
+        """Build the price difference, triple-smooth it, and set the min period."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        price1 = resolve_price_line(self.data, self.p.ipc1)
+        price2 = resolve_price_line(self.data, self.p.ipc2)
+        mom = price1 - price2(-max(0, int(self.p.xlength) - 1))
+        xmom = ma_cls(mom, period=max(1, int(self.p.xlength1)))
+        xxmom = ma_cls(xmom, period=max(1, int(self.p.xlength2)))
+        xxxmom = ma_cls(xxmom, period=max(1, int(self.p.xlength3)))
+        self._momentum = xxxmom
+        self.lines.value = 100.0 * xxxmom
+        self.addminperiod(
+            int(self.p.xlength)
+            + int(self.p.xlength1)
+            + int(self.p.xlength2)
+            + int(self.p.xlength3)
+            + 5
+        )

backtrader/indicators/contrib/blau_cmi_indicator.py

@@ -0,0 +1,141 @@
+#!/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,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "BlauCMIIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average name string to a Backtrader indicator class.
+
+    Args:
+        name: Method token from strategy config.
+
+    Returns:
+        Backtrader moving average class.
+    """
+    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
+
+
+def resolve_price_line(data, mode):
+    """Resolve a price selector token into a Backtrader line for arithmetic usage.
+
+    Args:
+        data: Backtrader data feed.
+        mode: Price selector string.
+
+    Returns:
+        Data feed line for the selected price.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_close", "close"}:
+        return data.close
+    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 (2.0 * data.close + data.high + data.low) / 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
+    return data.close
+
+
+class BlauCMIIndicator(Indicator):
+    """Compute the CMI oscillator from nested moving averages of momentum."""
+
+    lines = ("value",)
+    params = (
+        ("xma_method", "ema"),
+        ("xlength", 1),
+        ("xlength1", 20),
+        ("xlength2", 5),
+        ("xlength3", 3),
+        ("xphase", 15),
+        ("ipc1", "price_close"),
+        ("ipc2", "price_open"),
+    )
+
+    def __init__(self):
+        """Set up numerator/denominator moving averages for oscillator output."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        price1 = resolve_price_line(self.data, self.p.ipc1)
+        price2 = resolve_price_line(self.data, self.p.ipc2)
+        mom = price1 - price2(-max(0, int(self.p.xlength) - 1))
+        abs_mom = abs(mom)
+        xmom = ma_cls(mom, period=max(1, int(self.p.xlength1)))
+        xabsmom = ma_cls(abs_mom, period=max(1, int(self.p.xlength1)))
+        xxmom = ma_cls(xmom, period=max(1, int(self.p.xlength2)))
+        xxabsmom = ma_cls(xabsmom, period=max(1, int(self.p.xlength2)))
+        xxxmom = ma_cls(xxmom, period=max(1, int(self.p.xlength3)))
+        xxxabsmom = ma_cls(xxabsmom, period=max(1, int(self.p.xlength3)))
+        self._numerator = xxxmom
+        self._denominator = xxxabsmom
+        self.addminperiod(
+            int(self.p.xlength1)
+            + int(self.p.xlength2)
+            + int(self.p.xlength3)
+            + int(self.p.xlength)
+            + 5
+        )
+
+    def next(self):
+        """Populate the indicator value on a per-bar basis."""
+        den = float(self._denominator[0])
+        self.lines.value[0] = 100.0 * float(self._numerator[0]) / den if den else 0.0
+
+    def once(self, start, end):
+        """Compute indicator values in a vectorized range for Backtrader backfills."""
+        numerator = self._numerator.array
+        denominator = self._denominator.array
+        value_line = self.lines.value.array
+        while len(value_line) < end:
+            value_line.append(float("nan"))
+
+        actual_end = min(end, len(numerator), len(denominator))
+        for i in range(start, actual_end):
+            den = float(denominator[i])
+            value_line[i] = 100.0 * float(numerator[i]) / den if den else 0.0

backtrader/indicators/contrib/blau_csi.py

@@ -0,0 +1,76 @@
+#!/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__ = [
+    "BlauCSI",
+]
+
+
+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 BlauCSI(Indicator):
+    """Blau CSI indicator built from smoothed momentum vs. range."""
+
+    lines = ("main",)
+    params = (
+        ("xma_method", "ema"),
+        ("xlength", 1),
+        ("xlength1", 20),
+        ("xlength2", 5),
+        ("xlength3", 3),
+        ("ipc1", "close"),
+        ("ipc2", "open"),
+    )
+
+    def __init__(self):
+        """Initialize smoothed momentum and price-range lines for CSI output."""
+        shift = max(int(self.p.xlength) - 1, 0)
+        price1 = _price_series(self.data, self.p.ipc1)
+        price2 = _price_series(self.data, self.p.ipc2)
+        mom = price1 - price2(-shift)
+        price_range = Highest(self.data.high, period=max(int(self.p.xlength), 1)) - Lowest(
+            self.data.low, period=max(int(self.p.xlength), 1)
+        )
+
+        xmom = EMA(mom, period=int(self.p.xlength1))
+        xrange = EMA(price_range, period=int(self.p.xlength1))
+        xxmom = EMA(xmom, period=int(self.p.xlength2))
+        xxrange = EMA(xrange, period=int(self.p.xlength2))
+        xxxmom = EMA(xxmom, period=int(self.p.xlength3))
+        xxxrange = EMA(xxrange, period=int(self.p.xlength3))
+
+        self.l.main = btfunc.DivByZero(100.0 * xxxmom, xxxrange, zero=0.0)

backtrader/indicators/contrib/blau_ergodic.py

@@ -0,0 +1,53 @@
+#!/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,
+    Indicator,
+)
+
+__all__ = [
+    "BlauErgodic",
+]
+
+
+class BlauErgodic(Indicator):
+    """Blau Ergodic oscillator: triple-smoothed normalised momentum.
+
+    Price momentum and its absolute value are each triple-smoothed with EMAs;
+    the main line is 100 times their ratio (guarded against division by zero).
+    The signal line is an EMA of the main line, and spread is their difference.
+    """
+
+    lines = ("main", "signal", "spread")
+    params = (
+        ("xlength", 2),
+        ("xlength1", 20),
+        ("xlength2", 5),
+        ("xlength3", 3),
+        ("xlength4", 3),
+    )
+
+    def __init__(self):
+        """Build the triple-EMA momentum chain for main, signal and spread."""
+        shift = max(int(self.p.xlength) - 1, 1)
+        momentum = self.data.close - self.data.close(-shift)
+        abs_momentum = abs(momentum)
+
+        xmom = EMA(momentum, period=int(self.p.xlength1))
+        xxmom = EMA(xmom, period=int(self.p.xlength2))
+        xxxmom = EMA(xxmom, period=int(self.p.xlength3))
+
+        xabsmom = EMA(abs_momentum, period=int(self.p.xlength1))
+        xxabsmom = EMA(xabsmom, period=int(self.p.xlength2))
+        xxxabsmom = EMA(xxabsmom, period=int(self.p.xlength3))
+
+        self.l.main = btfunc.DivByZero(100.0 * xxxmom, xxxabsmom, zero=0.0)
+        self.l.signal = EMA(self.l.main, period=int(self.p.xlength4))
+        self.l.spread = self.l.main - self.l.signal

backtrader/indicators/contrib/blau_t_stoch_i.py

@@ -0,0 +1,72 @@
+#!/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__ = [
+    "BlauTStochI",
+]
+
+
+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 BlauTStochI(Indicator):
+    """Indicator generating a smoothed Blau T-Stoch histogram."""
+
+    lines = ("hist",)
+    params = (
+        ("xlength", 20),
+        ("xlength1", 5),
+        ("xlength2", 3),
+        ("xlength3", 8),
+        ("ipc", "close"),
+    )
+
+    def __init__(self):
+        """Build EMA-smoothed numerator and denominator terms for histogram output."""
+        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))
+        xrange = EMA(range_line, period=int(self.p.xlength1))
+        xxstoch = EMA(xstoch, period=int(self.p.xlength2))
+        xxrange = EMA(xrange, period=int(self.p.xlength2))
+        xxxstoch = EMA(xxstoch, period=int(self.p.xlength3))
+        xxxrange = EMA(xxrange, period=int(self.p.xlength3))
+
+        self.l.hist = btfunc.DivByZero(100.0 * xxxstoch, xxxrange, zero=0.0) - 50.0