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

backtrader/indicators/contrib/i_trend_indicator.py

@@ -0,0 +1,125 @@
+#!/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 (
+    BollingerBands,
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ITrendIndicator",
+]
+
+
+def get_price_line(data, price_mode):
+    """Return the price line of ``data`` matching the requested mode.
+
+    Args:
+        data: A data feed exposing open/high/low/close lines.
+        price_mode: Price selector such as close, open, high, low, median,
+            typical, or weighted (with optional ``price_*`` prefixes).
+
+    Returns:
+        The corresponding price line or derived price expression.
+
+    Raises:
+        ValueError: If ``price_mode`` is not recognised.
+    """
+    mode = str(price_mode).lower()
+    if mode in ("close", "price_close", "price_close_"):
+        return data.close
+    if mode in ("open", "price_open", "price_open_"):
+        return data.open
+    if mode in ("high", "price_high", "price_high_"):
+        return data.high
+    if mode in ("low", "price_low", "price_low_"):
+        return data.low
+    if mode in ("median", "price_median", "price_median_"):
+        return (data.high + data.low) / 2.0
+    if mode in ("typical", "price_typical", "price_typical_"):
+        return (data.high + data.low + data.close) / 3.0
+    if mode in ("weighted", "price_weighted", "price_weighted_"):
+        return (data.high + data.low + data.close + data.close) / 4.0
+    raise ValueError(f"Unsupported price mode: {price_mode}")
+
+
+def build_ma(price_line, period, ma_type):
+    """Construct a moving average indicator of the requested type.
+
+    Args:
+        price_line: The input price line to smooth.
+        period: Lookback length for the moving average.
+        ma_type: Moving average type (SMA, EMA, SMMA/LWMA or their ``MODE_*``
+            aliases).
+
+    Returns:
+        The instantiated moving average indicator.
+
+    Raises:
+        ValueError: If ``ma_type`` is not supported.
+    """
+    mode = str(ma_type).upper()
+    mapping = {
+        "MODE_SMA": SimpleMovingAverage,
+        "SMA": SimpleMovingAverage,
+        "MODE_EMA": ExponentialMovingAverage,
+        "EMA": ExponentialMovingAverage,
+        "MODE_SMMA": SmoothedMovingAverage,
+        "SMMA": SmoothedMovingAverage,
+        "MODE_LWMA": WeightedMovingAverage,
+        "LWMA": WeightedMovingAverage,
+    }
+    if mode not in mapping:
+        raise ValueError(f"Unsupported ma_type: {ma_type}")
+    return mapping[mode](price_line, period=period)
+
+
+class ITrendIndicator(Indicator):
+    """i_Trend indicator producing primary and signal crossover lines.
+
+    The ``primary`` line is the selected price minus a Bollinger band line and
+    the ``signal`` line is a moving average mirrored around the bar's high/low
+    range; their crossovers drive the strategy's entries and exits.
+    """
+
+    lines = ("primary", "signal")
+    params = (
+        ("price_type", "close"),
+        ("ma_period", 13),
+        ("ma_type", "EMA"),
+        ("ma_price", "close"),
+        ("bb_period", 20),
+        ("deviation", 2.0),
+        ("bb_price", "close"),
+        ("bb_mode", 0),
+    )
+
+    def __init__(self):
+        """Wire the moving average and Bollinger band into the output lines."""
+        price_type_line = get_price_line(self.data, self.p.price_type)
+        ma_price_line = get_price_line(self.data, self.p.ma_price)
+        bb_price_line = get_price_line(self.data, self.p.bb_price)
+        ma = build_ma(ma_price_line, int(self.p.ma_period), self.p.ma_type)
+        bands = BollingerBands(
+            bb_price_line, period=int(self.p.bb_period), devfactor=float(self.p.deviation)
+        )
+        mode = int(self.p.bb_mode)
+        if mode == 0:
+            band_line = bands.mid
+        elif mode == 1:
+            band_line = bands.top
+        elif mode == 2:
+            band_line = bands.bot
+        else:
+            raise ValueError(f"Unsupported bb_mode: {self.p.bb_mode}")
+        self.l.primary = price_type_line - band_line
+        self.l.signal = (ma * 2.0) - self.data.low - self.data.high
+        self.addminperiod(max(int(self.p.ma_period), int(self.p.bb_period)) + 5)

backtrader/indicators/contrib/iamma_indicator.py

@@ -0,0 +1,39 @@
+#!/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__ = [
+    "IAMMAIndicator",
+]
+
+
+class IAMMAIndicator(Indicator):
+    """Indicator implementation of i-AMMA value progression."""
+
+    lines = ("value",)
+    params = (
+        ("ma_period", 25),
+        ("price_shift", 0),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize i-AMMA offset and minimum startup bars."""
+        self.price_offset = float(self.p.point) * float(self.p.price_shift)
+        self.addminperiod(2)
+
+    def next(self):
+        """Compute adaptive MA value for current bar."""
+        if len(self) == 1:
+            self.l.value[0] = float(self.data.close[0])
+            return
+        period = max(int(self.p.ma_period), 1)
+        prev = float(self.l.value[-1])
+        price = float(self.data.close[0])
+        amma = (((period - 1) * (prev - self.price_offset)) + price) / period
+        self.l.value[0] = amma + self.price_offset

backtrader/indicators/contrib/indexed_moving_average.py

@@ -0,0 +1,33 @@
+#!/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,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "IndexedMovingAverage",
+]
+
+
+class IndexedMovingAverage(Indicator):
+    """Indicator that normalizes price-to-MA imbalance for directional signals."""
+
+    lines = ("ima",)
+    params = (("period", 5),)
+
+    def __init__(self):
+        """Initialize MA line and warmup period for indicator output."""
+        self.ma = SimpleMovingAverage(self.data.close, period=self.p.period)
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Write indexed moving-average deviation to ``lines.ima`` for current bar."""
+        ma = float(self.ma[0])
+        close = float(self.data.close[0])
+        self.lines.ima[0] = 0.0 if abs(ma) < 1e-12 else (close / ma) - 1.0

backtrader/indicators/contrib/instantaneous_trend_filter_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 Indicator
+
+__all__ = [
+    "InstantaneousTrendFilterIndicator",
+]
+
+
+class InstantaneousTrendFilterIndicator(Indicator):
+    """Indicator computing trend and trigger values from a low-lag trend filter."""
+
+    lines = ("trend", "trigger")
+    params = (("alpha", 0.07),)
+
+    def __init__(self):
+        """Initialize coefficients and warm-up requirements."""
+        alpha = float(self.p.alpha)
+        a2 = alpha * alpha
+        self.k0 = alpha - a2 / 4.0
+        self.k1 = 0.5 * a2
+        self.k2 = alpha - 0.75 * a2
+        self.k3 = 2.0 * (1.0 - alpha)
+        self.k4 = (1.0 - alpha) ** 2
+        self.addminperiod(1)
+
+    def next(self):
+        """Compute the current trend/trigger outputs."""
+        price0 = float(self.data.close[0])
+        if len(self) <= 4:
+            trend = price0
+        else:
+            price1 = float(self.data.close[-1])
+            price2 = float(self.data.close[-2])
+            trend = (
+                self.k0 * price0
+                + self.k1 * price1
+                - self.k2 * price2
+                + self.k3 * float(self.l.trend[-1])
+                - self.k4 * float(self.l.trend[-2])
+            )
+        self.l.trend[0] = trend
+        if len(self) <= 2:
+            self.l.trigger[0] = trend
+        else:
+            self.l.trigger[0] = 2.0 * trend - float(self.l.trend[-2])

backtrader/indicators/contrib/inverse_reaction_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__ = [
+    "InverseReactionIndicator",
+]
+
+
+class InverseReactionIndicator(Indicator):
+    """Indicator that tracks candle reaction amplitude and dynamic thresholds."""
+
+    lines = ("price_change", "upper_level", "lower_level")
+    params = (
+        ("ma_period", 3),
+        ("coefficient", 1.618),
+    )
+
+    def __init__(self):
+        """Set minimum required history for moving-average reaction computation."""
+        self.addminperiod(self.p.ma_period)
+
+    def next(self):
+        """Compute per-bar price-change and dynamic reaction upper/lower levels."""
+        price_change = float(self.data.close[0] - self.data.open[0])
+        self.lines.price_change[0] = price_change
+        if len(self) < self.p.ma_period:
+            self.lines.upper_level[0] = float("nan")
+            self.lines.lower_level[0] = float("nan")
+            return
+        total = 0.0
+        for i in range(self.p.ma_period):
+            total += abs(float(self.data.close[-i] - self.data.open[-i]))
+        dcl = (total / float(self.p.ma_period)) * float(self.p.coefficient)
+        self.lines.upper_level[0] = dcl
+        self.lines.lower_level[0] = -dcl

backtrader/indicators/contrib/irsi_sign_indicator.py

@@ -0,0 +1,95 @@
+#!/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 (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "IRSISignIndicator",
+]
+
+
+def _applied_price(data, price_type, ago=0):
+    """Resolve applied price by type and history shift."""
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if price_type == 0:
+        return c
+    if price_type == 1:
+        return o
+    if price_type == 2:
+        return h
+    if price_type == 3:
+        return low_price
+    if price_type == 4:
+        return (h + low_price) / 2.0
+    if price_type == 5:
+        return (h + low_price + c) / 3.0
+    if price_type == 6:
+        return (h + low_price + c + c) / 4.0
+    return c
+
+
+class IRSISignIndicator(Indicator):
+    """Compute RSI sign-flip levels and adaptive ATR-adjusted marker lines."""
+
+    lines = ("sell", "buy", "rsi", "atr")
+    params = (
+        ("atr_period", 14),
+        ("rsi_period", 14),
+        ("rsi_price", 0),
+        ("up_level", 70),
+        ("dn_level", 30),
+    )
+
+    def __init__(self):
+        """Initialize ATR series and minimum required history."""
+        self._atr = ATR(self.data, period=int(self.p.atr_period))
+        self.addminperiod(max(int(self.p.atr_period), int(self.p.rsi_period)) + 2)
+
+    def _calc_rsi(self):
+        """Calculate RSI manually from configured applied prices."""
+        period = int(self.p.rsi_period)
+        gains = []
+        losses = []
+        for i in range(period):
+            p0 = _applied_price(self.data, int(self.p.rsi_price), i)
+            p1 = _applied_price(self.data, int(self.p.rsi_price), i + 1)
+            delta = p0 - p1
+            gains.append(max(delta, 0.0))
+            losses.append(max(-delta, 0.0))
+        avg_gain = sum(gains) / period if period else 0.0
+        avg_loss = sum(losses) / period if period else 0.0
+        if avg_loss == 0.0:
+            return 100.0 if avg_gain > 0.0 else 50.0
+        rs = avg_gain / avg_loss
+        return 100.0 - (100.0 / (1.0 + rs))
+
+    def next(self):
+        """Update buy/sell marker levels and RSI / ATR output lines."""
+        self.lines.sell[0] = float("nan")
+        self.lines.buy[0] = float("nan")
+        rsi_now = self._calc_rsi()
+        self.lines.rsi[0] = rsi_now
+        self.lines.atr[0] = float(self._atr[0])
+
+        if len(self) < 2:
+            return
+
+        rsi_prev = float(self.lines.rsi[-1])
+        atr_now = float(self._atr[0])
+        low_now = float(self.data.low[0])
+        high_now = float(self.data.high[0])
+
+        if rsi_now > float(self.p.dn_level) and rsi_prev <= float(self.p.dn_level):
+            self.lines.buy[0] = low_now - atr_now * 3.0 / 8.0
+        if rsi_now < float(self.p.up_level) and rsi_prev >= float(self.p.up_level):
+            self.lines.sell[0] = high_now + atr_now * 3.0 / 8.0

backtrader/indicators/contrib/iwpr_sign_indicator.py

@@ -0,0 +1,59 @@
+#!/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 (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "IWPRSignIndicator",
+]
+
+
+class IWPRSignIndicator(Indicator):
+    """Indicator computing WPR buy/sell levels with ATR context."""
+
+    lines = ("sell", "buy", "wpr", "atr")
+    params = (
+        ("atr_period", 14),
+        ("wpr_period", 14),
+        ("up_level", -30),
+        ("dn_level", -70),
+    )
+
+    def __init__(self):
+        """Initialize ATR source and required lookback."""
+        self._atr = ATR(self.data, period=int(self.p.atr_period))
+        self.addminperiod(max(int(self.p.atr_period), int(self.p.wpr_period)) + 2)
+
+    def _calc_wpr(self):
+        period = int(self.p.wpr_period)
+        highs = [float(self.data.high[-i]) for i in range(period)]
+        lows = [float(self.data.low[-i]) for i in range(period)]
+        hh = max(highs)
+        ll = min(lows)
+        cp = float(self.data.close[0])
+        if hh == ll:
+            return -50.0
+        return -100.0 * (hh - cp) / (hh - ll)
+
+    def next(self):
+        """Compute WPR and create buy/sell trigger levels."""
+        self.lines.sell[0] = float("nan")
+        self.lines.buy[0] = float("nan")
+        wpr_now = self._calc_wpr()
+        self.lines.wpr[0] = wpr_now
+        self.lines.atr[0] = float(self._atr[0])
+        if len(self) < 2:
+            return
+        wpr_prev = float(self.lines.wpr[-1])
+        atr_now = float(self._atr[0])
+        if wpr_now > float(self.p.dn_level) and wpr_prev <= float(self.p.dn_level):
+            self.lines.buy[0] = float(self.data.low[0]) - atr_now * 3.0 / 8.0
+        if wpr_now < float(self.p.up_level) and wpr_prev >= float(self.p.up_level):
+            self.lines.sell[0] = float(self.data.high[0]) + atr_now * 3.0 / 8.0

backtrader/indicators/contrib/j_brain_trend1_sig_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 collections import deque
+
+from .. import (
+    ATR,
+    EMA,
+    RSI,
+    SMA,
+    Highest,
+    Indicator,
+    Lowest,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "JBrainTrend1SigIndicator",
+    "UltraRSIIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average style name to a Backtrader indicator class.
+
+    Args:
+        name: Requested moving-average mode, e.g., ``sma`` or ``ema``.
+
+    Returns:
+        Corresponding Backtrader moving-average indicator class.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SMA
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    if mode in {"lwma", "mode_lwma"}:
+        return WeightedMovingAverage
+    return EMA
+
+
+class CountSmoother:
+    """Track a rolling series of values and return a smoothed aggregate.
+
+    Supports EMA-like, SMA, LWMA, and SMMA update rules used by the RSI module.
+    """
+
+    def __init__(self, method, period):
+        """Initialize the smoother.
+
+        Args:
+            method: Smoothing method name.
+            period: Window size used by SMA/LWMA/SMMA/EMA-style calculations.
+        """
+        self.method = str(method).lower()
+        self.period = max(1, int(period))
+        self.state = None
+        self.values = deque(maxlen=self.period)
+
+    def update(self, value):
+        """Update the smoother with a new sample and return the current value.
+
+        Args:
+            value: New numeric sample.
+
+        Returns:
+            Smoothed value after applying the configured method.
+        """
+        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"}:
+            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 JBrainTrend1SigIndicator(Indicator):
+    """Generate directional trend-signal levels from ATR, stochastic, and MAs.
+
+    The indicator emits ``buy_signal`` and ``sell_signal`` pulses used by the
+    main strategy.
+    """
+
+    lines = (
+        "sell_signal",
+        "buy_signal",
+    )
+    params = (
+        ("atr_period", 7),
+        ("sto_period", 9),
+        ("ma_method", "sma"),
+        ("xlength", 7),
+    )
+
+    def __init__(self):
+        """Build ATR, highest/lowest price extremes, and smoothing primitives."""
+        ma_cls = resolve_ma_class(self.p.ma_method)
+        self.atr = ATR(self.data, period=self.p.atr_period)
+        self.highest = Highest(self.data.high, period=self.p.sto_period)
+        self.lowest = Lowest(self.data.low, period=self.p.sto_period)
+        self.jh = ma_cls(self.data.high, period=self.p.xlength)
+        self.jl = ma_cls(self.data.low, period=self.p.xlength)
+        self.jc = ma_cls(self.data.close, period=self.p.xlength)
+        self._d = 2.3
+        self._s = 1.5
+        self._x1 = 53.0
+        self._x2 = 47.0
+        self._p_state = 0
+        self._old_trend = 0
+        self.addminperiod(max(self.p.atr_period, self.p.sto_period, self.p.xlength) + 3)
+
+    def next(self):
+        """Evaluate one bar and update ``buy_signal``/``sell_signal`` outputs."""
+        self.lines.sell_signal[0] = 0.0
+        self.lines.buy_signal[0] = 0.0
+        highest = float(self.highest[0])
+        lowest = float(self.lowest[0])
+        close = float(self.data.close[0])
+        denom = highest - lowest
+        stochastic = 50.0 if denom == 0 else 100.0 * (close - lowest) / denom
+        atr_value = float(self.atr[0])
+        range_value = atr_value / self._d
+        range_shift = atr_value * self._s / 4.0
+        val3 = abs(float(self.jc[0]) - float(self.jc[-2]))
+
+        if stochastic < self._x2 and val3 > range_value:
+            self._p_state = 1
+        if stochastic > self._x1 and val3 > range_value:
+            self._p_state = 2
+        if val3 <= range_value:
+            return
+
+        if stochastic < self._x2 and self._p_state in (0, 1):
+            if self._old_trend > 0:
+                self.lines.sell_signal[0] = float(self.jh[0]) + range_shift
+            if len(self.data) > 1:
+                self._old_trend = -1
+        if stochastic > self._x1 and self._p_state in (0, 2):
+            if self._old_trend < 0:
+                self.lines.buy_signal[0] = float(self.jl[0]) - range_shift
+            if len(self.data) > 1:
+                self._old_trend = 1
+
+
+class UltraRSIIndicator(Indicator):
+    """Smooth RSI slope-count indicator with configurable averaging stages.
+
+    Counts bullish versus bearish RSI directional changes across multiple moving
+    average steps and smooths both counters for a stable signal.
+    """
+
+    lines = (
+        "bulls",
+        "bears",
+    )
+    params = (
+        ("rsi_period", 13),
+        ("applied_price", "close"),
+        ("w_method", "jjma"),
+        ("start_length", 3),
+        ("nstep", 5),
+        ("nsteps_total", 10),
+        ("smooth_method", "jjma"),
+        ("smooth_length", 3),
+    )
+
+    def __init__(self):
+        """Initialize RSI series and helper smoothing state."""
+        price_line = self._price_line()
+        ma_cls = resolve_ma_class(self.p.w_method)
+        self.rsi = RSI(price_line, period=self.p.rsi_period, safediv=True)
+        self._series = [
+            ma_cls(self.rsi, period=max(1, int(self.p.start_length + step * self.p.nstep)))
+            for step in range(int(self.p.nsteps_total) + 1)
+        ]
+        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.rsi_period
+            + self.p.start_length
+            + self.p.nstep * self.p.nsteps_total
+            + self.p.smooth_length
+            + 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
+        return self.data.close
+
+    def next(self):
+        """Update bullish and bearish counters and write smoothed values."""
+        up_count = 0
+        down_count = 0
+        for series in self._series:
+            current = float(series[0])
+            previous = float(series[-1])
+            if current > previous:
+                up_count += 1
+            elif current < previous:
+                down_count += 1
+        self.lines.bulls[0] = self._bull_smoother.update(up_count)
+        self.lines.bears[0] = self._bear_smoother.update(down_count)